展开

关键词

首页关键词lightweight

lightweight

相关内容

云服务器

云服务器

稳定、安全、弹性、高性能的云端计算服务,实时满足您的多样性业务需求
  • Lightweight Test Automation Framework之旅

    Lightweight Test Automation Framework是ASP.NET QA团队开发的自动化集成测试框架,并且应用在ASP.NET QA团队的自动化测试产品中,目前最新版本是April根据ASP.NET QA团队博客上发布的Lightweight Test Automation Framework April Release,这个版本主要是修复bug和增加一些新特性,主要特性如下:用户界面上的改进关于Lightweight Test Automation Framework的优点方面的介绍,引一段老赵的文章来说明:由于直接在浏览器中运行,它天生便支持现有的——以及未来可能出现的任意浏览器。如何在asp.net mvc项目中应用Lightweight Test Automation FrameworkASP.NET QA 团队说Lightweight Test Automation Framework首先去下载Lightweight Test Automation Framework 然后把Microsoft.Web.Testing.Lightweight.dll引用到项目中,在MVC项目的站点下建立一个目录
    来自:
    浏览:316
  • UWP 轻量级样式定义(Lightweight Styling)

    UWP 轻量级样式定义(Lightweight Styling) 发布于 2018-09-26 09:17 更新于 2018-12-14 01:54 在 UWP 中,可以通过给控件直接设置属性或在 Style本文将介绍 UWP 轻量级样式定义(Lightweight styling),你既不用写太多代码,又能获得更多的样式控制。----轻量级样式定义看一段简单的代码,你一定能立刻明白本文想说的是什么。本段代码摘抄自 XAML Lightweight styling - UWP app developer - Microsoft Docs image.png ▲ 按钮的颜色定制以上代码可以写在 Page本文会经常更新,请阅读原文: https:blog.walterlv.compostuwp-lightweight-xaml-styling.html ,以避免陈旧错误知识的误导,同时有更好的阅读体验。
    来自:
    浏览:141
  • Lightweight Architecture Decision Records | 雷达哔哔哔

    今天是《雷达哔哔哔》的第一篇,Blip是Lightweight Architecture Decision Records?技术管理者,开发设计人员关注问题:传统的重文档编写维护量大,随着业务发展,很难保持同步在一些敏捷项目中,随着关键文档的缺失、项目Knowledge及决策丢失导致长生命周期的项目知识传递问题解决方案:使用“ Lightweight所以技术雷达推荐使用“ Lightweight Architecture Decision Records”来记录项目的重要决策,相比于传统文档,它最大的特点就是轻量(Lightweight),关注于创造价值而不是遵循流程相关Blip及延展阅读:Lightweight Architecture Decision RecordsBlog | Documenting Architecture Decisions | RelevanceGitHubDecisions Within Our Repositories — Embedded ArtistryArchitectural Decision Records | adr.github.ioWhat are lightweight
    来自:
    浏览:267
  • 广告
    关闭

    50+款云产品免费体验

    提供包括云服务器,云数据库在内的50+款云计算产品。打造一站式的云产品试用服务,助力开发者和企业零门槛上云。

  • LightWeight RenderPipeline

    SRP一种通过C#脚本在Unity中配置和执行渲染的方法RenderPipeLine ?RenderPipeline.PNGForwardShading 原理:每个作用于物体的像素光单独计算一次,drawCall随着物体与光照数量增加而成倍增加 优点:不受硬件限制 缺点:光照计算开销成倍增加随着光源和物体数量增加。 每个物体接受光照数量有限。DeferredShading 原理:物体颜色、法线、材质等信息先渲染到G-Buffer中,光照最后单独渲染,避免每个物体多个光照批次的问题 优点:作用于每个物体光照数量不再受到限制,光照计算不随着物体增加而增加 缺点:移动设备需要支持OpenGL3.0。 不支持MSAA。 半透明物体仍然使用前向渲染。CommandBuffer 用于拓展Unity渲染管线。 包含一系列渲染命令,比如设置渲染目标,绘制网格等,并可以设置为在摄像机期间的各个点执行渲染。LWRP对性能改进 DrawCall->SRP Batcher 填充率->NewShading 内存带宽->NewRenderLWRP特性 1.精简优化过的渲染管线: 聚焦于性能、针对移动和XR平台 2.Single-Pass ForwardRendering: 高性能和高一致性的PBR 新Shader库 一次渲染多个实时光 可插入ScriptableRenderPasses 3.基于C#源码: 渲染过程可读 4.图形功能课定制化 增加、修改、删除、学习光照 1.实时光照: 按照每个物体进行光照剔除 在一个批次进行渲染 针对每个物体限制:一盏主方向光、四盏附加光 每个相机16盏可见光 2.给予物理的光照衰减: 只受强度控制,不受范围影响相关资料: 官方LWRP讲解 https:www.bilibili.comvideoav38056528 LWRP管线剖析 https:blog.csdn.netqq_37043683articledetails80989492 民间文档https:blog.csdn.netweixin_42163773articledetails84317223
    来自:
    浏览:377
  • greenlet: Lightweight concurrent programming

    https:greenlet.readthedocs.ioenlatestMotivationThe “greenlet” package is a spin-off of Stackless, a version of CPython that supports micro-threads called “tasklets”. Tasklets run pseudo-concurrently (typically in a single or a few OS-level threads) and are synchronized with data exchanges on “channels”.A “greenlet”, on the other hand, is a still more primitive notion of micro-thread with no implicit scheduling; coroutines, in other words. This is useful when you want to control exactly when your code runs. You can build custom scheduled micro-threads on top of greenlet; however, it seems that greenlets are useful on their own as a way to make advanced control flow structures. For example, we can recreate generators; the difference with Python’s own generators is that our generators can call nested functions and the nested functions can yield values too. (Additionally, you don’t need a “yield” keyword. See the example in testtest_generator.py ).Greenlets are provided as a C extension module for the regular unmodified interpreter.ExampleLet’s consider a system controlled by a terminal-like console, where the user types commands. Assume that the input comes character by character. In such a system, there will typically be a loop like the following one:def process_commands(*args): while True: line = while not line.endswith(n): line += read_next_char() if line == quitn: print are you sure? if read_next_char() != y: continue # ignore the command process_command(line)Now assume that you want to plug this program into a GUI. Most GUI toolkits are event-based. They will invoke a call-back for each character the user presses. In this setting, it is difficult to implement the read_next_char() function needed by the code above. We have two incompatible functions:def event_keydown(key): ?? def read_next_char(): ?? should wait for the next event_keydown() callYou might consider doing that with threads. Greenlets are an alternate solution that don’t have the related locking and shutdown problems. You start the process_commands() function in its own, separate greenlet, and then you exchange the keypresses with it as follows:def event_keydown(key): # jump into g_processor, sending it the key g_processor.switch(key) def read_next_char(): # g_self is g_processor in this simple example g_self = greenlet.getcurrent() # jump to the parent (main) greenlet, waiting for the next key next_char = g_self.parent.switch() return next_char g_processor = greenlet(process_commands)g_processor.switch(*args) # input arguments to process_commands() gui.mainloop()In this example, the execution flow is: when read_next_char() is called, it is part of the g_processor greenlet, so when it switches to its parent greenlet, it resumes execution in the top-level main loop (the GUI). When the GUI calls event_keydown(), it switches to g_processor, which means that the execution jumps back wherever it was suspended in that greenlet – in this case, to the switch() instruction in read_next_char() – and the key argument in event_keydown() is passed as the return value of the switch() in read_next_char().Note that read_next_char() will be suspended and resumed with its call stack preserved, so that it will itself return to different positions in process_commands() depending on where it was originally called from. This allows the logic of the program to be kept in a nice control-flow way; we don’t have to completely rewrite process_commands() to turn it into a state machine.UsageIntroductionA “greenlet” is a small independent pseudo-thread. Think about it as a small stack of frames; the outermost (bottom) frame is the initial function you called, and the innermost frame is the one in which the greenlet is currently paused. You work with greenlets by creating a number of such stacks and jumping execution between them. Jumps are never implicit: a greenlet must choose to jump to another greenlet, which will cause the former to suspend and the latter to resume where it was suspended. Jumping between greenlets is called “switching”.When you create a greenlet, it gets an initially empty stack; when you first switch to it, it starts to run a specified function, which may call other functions, switch out of the greenlet, etc. When eventually the outermost function finishes its execution, the greenlet’s stack becomes empty again and the greenlet is “dead”. Greenlets can also die of an uncaught exception.For example:from greenlet import greenlet def test1(): print 12 gr2.switch() print 34 def test2(): print 56 gr1.switch() print 78 gr1 = greenlet(test1)gr2 = greenlet(test2)gr1.switch()The last line jumps to test1, which prints 12, jumps to test2, prints 56, jumps back into test1, prints 34; and then test1 finishes and gr1 dies. At this point, the execution comes back to the original gr1.switch() call. Note that 78 is never printed.ParentsLet’s see where execution goes when a greenlet dies. Every greenlet has a “parent” greenlet. The parent greenlet is initially the one in which the greenlet was created (this can be changed at any time). The parent is where execution continues when a greenlet dies. This way, greenlets are organized in a tree. Top-level code that doesn’t run in a user-created greenlet runs in the implicit “main” greenlet, which is the root of the tree.In the above example, both gr1 and gr2 have the main greenlet as a parent. Whenever one of them dies, the execution comes back to “main”.Uncaught exceptions are propagated into the parent, too. For example, if the above test2() contained a typo, it would generate a NameError that would kill gr2, and the exception would go back directly into “main”. The traceback would show test2, but not test1. Remember, switches are not calls, but transfer of execution between parallel “stack containers”, and the “parent” defines which stack logically comes “below” the current one.Instantiationgreenlet.greenlet is the greenlet type, which supports the following operations:greenlet(run=None, parent=None) Create a new greenlet object (without running it). run is the callable to invoke, and parent is the parent greenlet, which defaults to the current greenlet. greenlet.getcurrent() Returns the current greenlet (i.e. the one which called this function). greenlet.GreenletExit This special exception does not propagate to the parent greenlet; it can be used to kill a single greenlet. The greenlet type can be subclassed, too. A greenlet runs by calling its run attribute, which is normally set when the greenlet is created; but for subclasses it also makes sense to define a run method instead of giving a run argument to the constructor.SwitchingSwitches between greenlets occur when the method switch() of a greenlet is called, in which case execution jumps to the greenlet whose switch() is called, or when a greenlet dies, in which case execution jumps to the parent greenlet. During a switch, an object or an exception is “sent” to the target greenlet; this can be used as a convenient way to pass information between greenlets. For example:def test1(x, y): z = gr2.switch(x+y) print z def test2(u): print u gr1.switch(42) gr1 = greenlet(test1)gr2 = greenlet(test2)gr1.switch(hello, world)
    来自:
    浏览:160
  • 【每周一库】 simsearch - a simple and lightweight fuzzy search engine

    本期的每周一库带来的是simsearch,一个运行在内存的轻量级字符串模糊搜索引擎。首先列出库的链接github: simsearchdocs.rs: simsearch接下来我们通过simsearch gihub中给出的例子来试用开发环境rustc --version: rustc 1.45.2 (d3fb005a3 2020-07-31)cargo --version: cargo 1.45.1 (f242df6ed 2020-07-22)首先在Cargo.toml文件中添加依赖项simsearch = 0.2image.pnguse simsearch::SimSearch;use std::time::Instant; fn main(){ let mut engine: SimSearch = SimSearch::new(); engine.insert(1, Things Fall Apart); engine.insert(2, The Old Man and the Sea); engine.insert(3, James Joyce has somethings); let pattern = thngs; let start = Instant::now(); let res = engine.search(&pattern); let end = Instant::now(); println!(pattern: {:?}, pattern.trim()); println!(results: {:?}, res); println!(time: {:?}, end - start);} 运行结果如下 ?接下来我们调整插入的第三个字符串为James Joyce has some things,期望是能够通过搜索patternthngs找到第一个字符串和第三个字符串,运行结果如下: ?以上就是本期的每周一库
    来自:
    浏览:141
  • GPU 云服务器

    腾讯GPU 云服务器是提供 GPU 算力的弹性计算服务,具有超强的并行计算能力,作为 IaaS 层的尖兵利器,服务于深度学习训练、科学计算、图形图像处理、视频编解码等场景……
    来自:
  • FPGA 云服务器

    腾讯FPGA云服务器是基于FPGA硬件可编程加速的弹性计算服务,您只需几分钟就可以获取并部署您的FPGA实例。结合IP市场提供的图片,视频,基因等相关领域的计算解决方案,提供无与伦比的计算加速能力……
    来自:
  • 专用宿主机

    专用宿主机(CDH)提供用户独享的物理服务器资源,满足您资源独享、资源物理隔离、安全、合规需求。专用宿主机搭载了腾讯云虚拟化系统,购买之后,您可在其上灵活创建、管理多个自定义规格的云服务器实例,自主规划物理资源的使用。
    来自:
  • 黑石物理服务器2.0

    腾讯黑石物理服务器2.0(CPM)是一种包年包月的裸金属云服务,为您提供云端独享的高性能、无虚拟化的、安全隔离的物理服务器集群。使用该服务,您只需根据业务特性弹性伸缩物理服务器数量,获取物理服务器的时间将被缩短至分钟级。
    来自:
  • 容器服务

    腾讯云容器服务(Tencent Kubernetes Engine ,TKE)基于原生kubernetes提供以容器为核心的、高度可扩展的高性能容器管理服务。腾讯云容器服务完全兼容原生 kubernetes API ,扩展了腾讯云的云硬盘、负载均衡等 kubernetes 插件,为容器化的应用提供高效部署、资源调度、服务发现和动态伸缩等一系列完整功能,解决用户开发、测试及运维过程的环境一致性问题,提高了大规模容器集群管理的便捷性,帮助用户降低成本,提高效率。容器服务提供免费使用,涉及的其他云产品另外单独计费。
    来自:
  • 弹性伸缩

    腾讯弹性伸缩(AS)为您提供高效管理计算资源的策略。您可设定时间周期性地执行管理策略或创建实时监控策略,来管理 CVM 实例数量,并完成对实例的环境部署,保证业务平稳顺利运行。弹性伸缩策略不仅能够让需求稳定规律的应用程序实现自动化管理,同时告别业务突增或CC攻击等带来的烦恼,对于每天、每周、每月使用量不停波动的应用程序还能够根据业务负载分钟级扩展。
    来自:
  • 云函数

    云函数(Serverless Cloud Function,SCF)是腾讯云为企业和开发者们提供的无服务器执行环境,帮助您在无需购买和管理服务器的情况下运行代码。您只需使用平台支持的语言编写核心代码并设置代码运行的条件,即可在腾讯云基础设施上弹性、安全地运行代码。SCF 是实时文件处理和数据处理等场景下理想的计算平台。
    来自:
  • 批量计算

    批量计算(Batch)是为有大数据计算业务的企业、科研单位等提供高性价比且易用的计算服务。批量计算可以根据用户提供的批处理规模,智能地管理作业和调动所其需的最佳资源……
    来自:
  • 消息队列 CMQ

    腾讯云消息队列(CMQ)是一种分布式消息队列服务,它能够提供可靠的基于消息的异步通信机制,能够将分布式部署的不同应用(或同一应用的不同组件)之间的收发消息,存储在可靠有效的 CMQ 队列中,防止消息丢失。CMQ 支持多进程同时读写,收发互不干扰,无需各应用或组件始终处于运行状态。
    来自:
  • 消息队列 CKafka

    CKafka(Cloud Kafka)是一个分布式的、高吞吐量、高可扩展性的消息系统,100%兼容开源 Kafka API(0.9版本)。Ckafka 基于发布/订阅模式,通过消息解耦,使生产者和消费者异步交互,无需彼此等待。Ckafka 具有数据压缩、同时支持离线和实时数据处理等优点,适用于日志压缩收集、监控数据聚合等场景。
    来自:
  • API 网关

    腾讯云 API 网关(API Gateway)是腾讯云推出的一种 API 托管服务,能提供 API 的完整生命周期管理,包括创建、维护、发布、运行、下线等。您可使用 API 网关封装自身业务,将您的数据、业务逻辑或功能安全可靠的开放出来,用以实现自身系统集成、以及与合作伙伴的业务连接。
    来自:
  • 微服务平台 TSF

    腾讯微服务平台(TSF)是一个围绕应用和微服务的 PaaS 平台,提供一站式应用全生命周期管理能力和数据化运营支持,提供多维度应用和服务的监控数据,助力服务性能优化。
    来自:
  • 对象存储

    腾讯云对象存储数据处理方案主要针对于存储于腾讯云对象存储COS中的数据内容进行处理加工,满足压缩、转码、编辑、分析等多种诉求,激活数据价值。
    来自:

扫码关注云+社区

领取腾讯云代金券