Unity DOTS中的baking（四）blob assets

Unity DOTS中的baking（四）blob assets

blob assets表示不可变的二进制数据，在运行时也不会发生更改。由于blob assets是只读的，这意味着可以安全地并行访问它们。此外，blob assets仅限于使用非托管类型，这意味着它们与Burst编译器兼容。而且由于它们是非托管类型，序列化和反序列化的速度要比其他数据格式快得多。blob assets只能包含值类型，除了标准的值类型之外，还支持三种特殊的数据类型：BlobArray, BlobPtr, BlobString。

在baking中创建一个blob asset的过程，可以分为以下若干步骤：

  1. 创建一个BlobBuilder，它在Unity内部分配一些内存；
  2. 调用BlobBuilder.ConstructRoot构造blob asset的根节点；
  3. 把需要的数据填充到上一步骤返回的根节点中；
  4. 调用BlobBuilder.CreateBlobAssetReference创建一个BlobAssetReference。这个API会把blob asset复制到最终位置；
  5. 释放第一步创建的BlobBuilder；
  6. 调用AddBlobAsset将blob asset注册到baker中，如果不执行这一步，blob asset的引用计数将不会更新，也就是说blob asset可能会被意外释放；
  7. 调用AddComponent将BlobAssetReference添加到entity上。

在官网了解完这些理论知识之后，我们来动手实践一下。首先定义一个BlobAssetReference引用的struct MyBlobData，它包含一个BlobArray和一个int：

public struct MyBlobData
{
    public BlobArray<int> blobArray;
    public int blobInt;
}

然后再定义一个component，它包含一个BlobAssetReference：

public struct MyBlobComponent : IComponentData
{
    public BlobAssetReference<MyBlobData> blobReference;
}

接下来就是根据上面所说的步骤，创建出BlobAssetReference：

public BlobAssetReference<MyBlobData> CreateBlobData()
{
    using (var blobBuilder = new BlobBuilder(Allocator.TempJob))
    {
        ref var root = ref blobBuilder.ConstructRoot<MyBlobData>();
        var array = blobBuilder.Allocate(ref root.blobArray, 10);
        for (int i = 0; i < 10; i++)
        {
            array[i] = i;
        }
        root.blobInt = 42;
        return blobBuilder.CreateBlobAssetReference<MyBlobData>(Allocator.Persistent);
    }
}

最后就是把BlobAssetReference注册到baker里去：

public override void Bake(MyBlobAssetAuthoring authoring)
{
    var entity = GetEntity(TransformUsageFlags.None);
    var blobReference = CreateBlobData();
    AddBlobAsset(ref blobReference, out _);
    AddComponent(entity, new MyBlobComponent { blobReference = blobReference });
}

此时在Unity里，可以看到MyBlobComponent，但是无法看到component里数据的详细信息：

Unity DOTS中的baking（四）1

我们可以借助System，在运行时打印这个component的信息：

foreach (var blob in SystemAPI.Query<RefRW<MyBlobComponent>>())
{
    int x = blob.ValueRO.blobReference.Value.blobArray[4];
    int y = blob.ValueRO.blobReference.Value.blobInt;
    Debug.Log(string.Format ("{0}, {1}", x, y));
}

Unity DOTS中的baking（四）2

可以看到一切正常。那么，我们现在回过头来，看看Unity官方文档中创建一个blob asset的过程，每一步骤背后究竟做了哪些事情。

第一步，创建BlobBuilder，BlobBuilder的构造函数会初始化内部使用的若干成员变量：

/// <summary>
/// Constructs a BlobBuilder object.
/// </summary>
/// <param name="allocator">The type of allocator to use for the BlobBuilder's internal, temporary data. Use
/// <see cref="Unity.Collections.Allocator.Temp"/> unless the BlobBuilder exists across more than four Unity frames.</param>
/// <param name="chunkSize">(Optional) The minimum amount of memory to allocate while building an asset.
/// The default value should suit most use cases. A smaller chunkSize results in more allocations; a larger
/// chunkSize could increase the BlobBuilder's total memory allocation (which is freed when you dispose of
/// the BlobBuilder.</param>
public BlobBuilder(AllocatorManager.AllocatorHandle allocator, int chunkSize = 65536)
{
    m_allocator = allocator;
    m_allocations = new NativeList<BlobAllocation>(16, m_allocator);
    m_patches = new NativeList<OffsetPtrPatch>(16, m_allocator);
    m_chunkSize = CollectionHelper.Align(chunkSize, 16);
    m_currentChunkIndex = -1;
}

注释中提到了两个参数的作用，allocator用于BlobBuilder内部数据的分配，除非BlobBuilder的生命周期很长，否则就应该使用Allocator.Temp，用完就回收；chunkSize用来控制BlobBuilder存放数据的内存块大小，太小的话会导致多次内存分配，太大则会导致内存占用负担，一般用默认值就可以了。

函数体内部初始化了5个成员变量，m_allocations是一个BlobAllocation类型的list，它记录了每个内存块chunk当前的状态，即内存块的起始指针p，和当前已经分配掉的内存大小size。

struct BlobAllocation
{
    public int size;
    public byte* p;
}

m_patches则是一个OffsetPtrPatch类型的list，它记录了需要patch的数据结构内存分配的信息。什么是需要patch的数据结构？我们前面提到blob assets除了支持标准值类型之外，还支持BlobArray, BlobPtr, BlobString这三种类型。这三种类型的变量，在初始化时往往还没有真正地分配所需要的内存，后续分配内存时，需要通过一种方式把变量和内存关联起来。OffsetPtrPatch类型记录了变量的起始地址指针offsetPtr，以及与变量关联的内存分配信息target，还有一个length字段记录数组的长度。

struct OffsetPtrPatch
{
    public int* offsetPtr;
    public BlobDataRef target;
    public int length; // if length != 0 this is an array patch and the length should be patched
}

BlobDataRef类型包含此次内存分配所在的chunk index，以及在chunk中的内存偏移量offset：

struct BlobDataRef
{
    public int allocIndex;
    public int offset;
}

m_chunkSize就是存放数据的内存块大小，这里会对传入的参数值进行处理，返回一个16字节对齐的大小。对齐函数的实现也蛮有趣的：

/// <summary>
/// Returns an allocation size in bytes that factors in alignment.
/// </summary>
/// <example><code>
/// // 55 aligned to 16 is 64.
/// int size = CollectionHelper.Align(55, 16);
/// </code></example>
/// <param name="size">The size to align.</param>
/// <param name="alignmentPowerOfTwo">A non-zero, positive power of two.</param>
/// <returns>The smallest integer that is greater than or equal to `size` and is a multiple of `alignmentPowerOfTwo`.</returns>
/// <exception cref="ArgumentException">Thrown if `alignmentPowerOfTwo` is not a non-zero, positive power of two.</exception>
public static int Align(int size, int alignmentPowerOfTwo)
{
    if (alignmentPowerOfTwo == 0)
        return size;

    CheckIntPositivePowerOfTwo(alignmentPowerOfTwo);

    return (size + alignmentPowerOfTwo - 1) & ~(alignmentPowerOfTwo - 1);
}

首先要检查传入的对齐字节数是不是2的幂：

[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS"), Conditional("UNITY_DOTS_DEBUG")]
internal static void CheckIntPositivePowerOfTwo(int value)
{
    var valid = (value > 0) && ((value & (value - 1)) == 0);
    if (!valid)
    {
        throw new ArgumentException($"Alignment requested: {value} is not a non-zero, positive power of two.");
    }
}

2的幂的二进制表示为1000…000，减一则为01111…111，按位与之后必为0。

所谓的字节对齐，就是要找到离传入参数值最接近的字节对齐的倍数。那么，我们只需要对原来的size加上alignmentPowerOfTwo - 1，就能保证得到的值一定超过了这个最接近的对齐值。接下来只要把超出的部分去掉就可以了，对alignmentPowerOfTwo - 1取反得到的就是1111…1000…000，后面的这些0就是个mask，按位与这个mask就可以去掉超出的部分了。

最后一个成员变量，m_currentChunkIndex，表示当前已经分配到的chunk index，初始化时还没开始内存分配，默认为-1。

第二步，调用ConstructRoot创建根节点，它会分配出足够容纳传入类型T的空间。

/// <summary>
/// Creates the top-level fields of a single blob asset.
/// </summary>
/// <remarks>
/// This function allocates memory for the top-level fields of a blob asset and returns a reference to it. Use
/// this root reference to initialize field values and to allocate memory for arrays and structs.
/// </remarks>
/// <typeparam name="T">A struct that defines the structure of the blob asset.</typeparam>
/// <returns>A reference to the blob data under construction.</returns>
public ref T ConstructRoot<T>() where T : struct
{
    var allocation = Allocate(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>());
    return ref UnsafeUtility.AsRef<T>(AllocationToPointer(allocation));
}

UnsafeUtility.SizeOf<T>()会返回struct的大小，这里的大小是带有padding的，比如我们这里的struct MyBlobData，返回的大小为12。UnsafeUtility.AlignOf<T>()返回的是struct的对齐字节，对于struct MyBlobData，对齐字节为4，如果MyBlobData中包含一个long成员，对齐字节就是8了。

下层的Allocate函数会根据传入的参数size和alignment进行内存分配。函数返回一个BlobDataRef类型的变量，表示此次分配的结果，即分配到了哪个chunk，以及在chunk中的地址。内存分配的策略其实不算复杂，我们这里不去分析代码，而是使用图示的方式来表达。

首先，初始情况下，m_currentChunkIndex为-1，那么需要直接分配一个chunk，然后将m_currentChunkIndex设置为0，并保存分配的chunk信息。由于是一个空白的chunk，那么就可以从chunk的首地址开始分配。

Unity DOTS中的baking（四）3

如图所示，p和size表示本次分配之后的chunk信息，p为chunk的首地址，size为已经分配掉的内存大小；allocIndex和offset表示本次分配的结果，allocIndex表示分配的内存在第0号chunk上，offset表示分配的内存首地址相对于chunk的首地址偏移量，这里为0。

有了chunk之后，后续的内存分配都在这个chunk上进行。为了保证存取数据的效率，后续分配的首地址都在对应struct的对齐字节整数倍上进行。

Unity DOTS中的baking（四）4

如图所示，第二次分配后，chunk的size信息需要更新为两次分配的内存大小，以及第二次分配用于字节对齐的大小总和。此次分配的结果，offset不再为0，而是chunk空闲的首地址再加上用于字节对齐的偏移量。

举个通俗的例子，假如第一次分配了12字节的struct内存，而第二次要分配的struct，总共64字节，但它是8字节对齐的，那么这里就不会紧挨着从12字节的位置继续分配，而是计算8字节对齐的整数倍，也就是16字节处，开始分配这个struct。这样两个struct之间其实是有4个字节的间隙，用于第二个struct字节对齐的。

当chunk剩余的内存空间不足时，就会再去申请一个新的chunk，同时会把上一个chunk中已经分配的空间调整到16字节对齐，这是因为chunk都是按照16字节对齐的地址进行分配的。

Unity DOTS中的baking（四）5

那如果需要分配的内存，超过一个chunk的大小，要怎么办呢？Unity会先计算一个16字节对齐后的大小，然后直接分配一个这样大的chunk。也就是说，Unity内部维护的chunk list，每个chunk的大小其实未必相同。

根据Allocate函数返回的分配结果，要如何转换成对应T类型的对象呢？我们前面提到，分配的结果，包含了分配的chunk索引，以及在chunk中的地址偏移量。那么只需要拿到chunk的首地址，加上偏移量就能得到实际分配T类型对象的指针了：

void* AllocationToPointer(BlobDataRef blobDataRef)
{
    return m_allocations[blobDataRef.allocIndex].p + blobDataRef.offset;
}

再把指针强转成对象即可。

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static ref T AsRef<T>(void* ptr) where T : struct
{
    return ref *(T*)ptr;
}

第三步，我们的Component中还包含了BlobArray，那么也需要为它分配内存，这里调用的是BlobBuilder.Allocate函数，它接受一个BlobArray对象的引用，以及要创建的数组大小这两个参数，返回一个BlobBuilderArray类对象，这个对象封装了数组访问的行为。

/// <summary>
/// Allocates enough memory to store <paramref name="length"/> elements of struct <typeparamref name="T"/>.
/// </summary>
/// <param name="ptr">A reference to a BlobArray field in a blob asset.</param>
/// <param name="length">The number of elements to allocate.</param>
/// <typeparam name="T">The struct data type.</typeparam>
/// <returns>A reference to the newly allocated array as a mutable BlobBuilderArray instance.</returns>
public BlobBuilderArray<T> Allocate<T>(ref BlobArray<T> ptr, int length) where T : struct
{
    return Allocate(ref ptr, length, UnsafeUtility.AlignOf<T>());
}

数组对象的内存分配逻辑与我们之前说的根节点内存分配逻辑大体相似，只不过这里需要额外考虑一点，如何把新分配的数组内存，与对象本身关联起来。分配数组内存的时机，往往是在对象初始化之后。Unity这里会把对象的地址，此次内存分配的结果，以及分配数组的长度，记录在OffsetPtrPatch类型的变量中。

Unity DOTS中的baking（四）6

返回的BlobBuilderArray类型是一个相当简单的数据结构，仅仅包含一个数据指针以及数组长度：

/// <summary>
/// Used by the <see cref="BlobBuilder"/> methods to reference the arrays within a blob asset.
/// </summary>
/// <remarks>Use this reference to initialize the data of a newly created <see cref="BlobArray{T}"/>.</remarks>
/// <typeparam name="T">The data type of the elements in the array.</typeparam>
public unsafe ref struct BlobBuilderArray<T> where T : struct
{
    private void* m_data;
    private int m_length;
}

这个struct重载了下标操作符，方便读写数据：

/// <summary>
/// Array index accessor for the elements in the array.
/// </summary>
/// <param name="index">The sequential index of an array item.</param>
/// <exception cref="IndexOutOfRangeException">Thrown when index is less than zero or greater than the length of the array (minus one).</exception>
public ref T this[int index]
{
    get
    {
        CheckIndexOutOfRange(index);
        return ref UnsafeUtility.ArrayElementAsRef<T>(m_data, index);
    }
}

ArrayElementAsRef就是个指针的计算操作：

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static ref T ArrayElementAsRef<T>(void* ptr, int index) where T : struct
{
    return ref *(T*)((byte*)ptr + (long)index * (long)sizeof(T));
}

到目前为止，数组的内存和对象还没有正确关联起来。这个实际上是在第4步，创建BlobAssetReference对象时完成的。CreateBlobAssetReference会把上面几步分配的内存拷贝到最终的位置上。

在拷贝之前，Unity做了若干准备工作，首先是定义了一个offsets数组，每个offset等于前一个offset加上当前chunk已经分配的内存大小，最后一个offset的值就是所有chunk分配的内存大小之和；然后还定义了sortedAllocs和sortedPatches两个数组，它们分别保存的是每个chunk的首地址和每个待关联对象的首地址，并且根据地址的高低进行了排序。

Unity DOTS中的baking（四）7

然后，Unity会分配一个长度为要拷贝的数据大小再加上BlobAssetHeader这一数据结构大小的buffer。offsets其实就是每个要拷贝的数据位于buffer的地址偏移。之后，Unity将每个chunk挨个拷贝到buffer中去，由于chunk之前已经做过16字节对齐了，这里就不需要再做其他工作了。

Unity DOTS中的baking（四）8

下一步，Unity开始把BlobArray，BlobPtr, BlobString这几种类型的变量和内存进行关联。首先要找到变量和内存分别在buffer中所对应的地址，两个地址相减得到真正的offset。

Unity DOTS中的baking（四）9

最关键的一步来了，回填，我们先看下BlobArray，BlobPtr, BlobString这几种类型的数据结构：

public unsafe struct BlobString
{
    internal BlobArray<byte> Data;
}

public unsafe struct BlobPtr<T> where T : struct
{
    internal int m_OffsetPtr;
}

public unsafe struct BlobArray<T> where T : struct
{
    internal int m_OffsetPtr;
    internal int m_Length;
}

它们有个共同特点，就是前4个字节，都是存放了一个int类型的offset ptr。这个值表示变量指向的内存地址距离变量自身的地址偏移量。直到此时此刻才会被填充。如果被指向的内存还包含长度信息，说明变量是BlobArray类型的，那么还需要回填一下数组的长度。

Unity DOTS中的baking（四）10

最后一步，Unity会填充header的信息，BlobAssetHeader是一个占用32字节的struct，它强制定义了内存的布局：

unsafe struct BlobAssetHeader
{
    [FieldOffset(0)]  public void* ValidationPtr;
    [FieldOffset(8)]  public int Length;
    [FieldOffset(12)] public AllocatorManager.AllocatorHandle Allocator;
    [FieldOffset(16)] public ulong Hash;
    [FieldOffset(24)] private ulong Padding;
}

其中，ValidationPtr表示存放数据的首地址。函数最后返回的是BlobAssetReference类型的对象，该对象也包含一个指针，指向存放数据的首地址。

Unity DOTS中的baking（四）11

最后，我们来提一下AddBlobAsset这个函数。本文开头提到，这个函数是用来将blob asset注册到baker中的，如果不注册blob asset可能会被错误释放。这里Unity实现的技巧比较trick，和所谓的引用计数毫无关系：

internal void ProtectAgainstDisposal()
{
    ValidateNotNull();

    if (IsProtected)
    {
        throw new InvalidOperationException("Cannot protect this BlobAssetReference, it is already protected.");
    }
#if UNITY_64
    Header->ValidationPtr = (void*)~(long)m_Ptr;
#else
    Header->ValidationPtr = (void*)~(int)m_Ptr;
#endif
}

Unity会把blob asset header的ValidationPtr进行修改，让它不再指向原来存放数据的位置。然后Unity就可以通过比较ValidationPtr和数据的首地址，判断当前blob asset是否被引用住：

bool IsProtected
{
    get
    {
#if UNITY_64
        return Header->ValidationPtr == (void*)~(long)m_Ptr;
#else
        return Header->ValidationPtr == (void*)~(int)m_Ptr;
#endif
    }
}

如果被引用住了，Dispose时则不会释放该blob asset。

public void Dispose()
{
    ValidateNotNull();
    ValidateNotProtected();
    ValidateNotDeserialized();
    Memory.Unmanaged.Free(Header, Header->Allocator);
    m_Ptr = null;
}

Reference

[1] Blob assets

[2] Create a blob asset

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/491615.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

网络爬虫基本知识

网络爬虫基本知识

什么是网络爬虫 网络爬虫&#xff08;Web crawler&#xff09;是一种自动化程序&#xff0c;用于在互联网上收集信息。它可以通过扫描和解析网页的超链接&#xff0c;自动访问网页并抓取所需的数据。网络爬虫常用于搜索引擎和数据采集工具中。 作用 通过有效的爬虫手段批量采…
阅读更多...
C语言中位运算介绍

C语言中位运算介绍

在C语言中&#xff0c;位运算是一种对二进制位进行操作的运算方式&#xff0c;它可以对数据的二进制表示进行位级别的操作&#xff0c;包括按位与、按位或、按位异或、按位取反等。位运算常用于处理底层数据结构、优化代码性能以及实现各种算法。本文将深入介绍C语言中的位运算…
阅读更多...
如何使用Python结合Pillow、matplotlib和OpenCV实现图片读取

如何使用Python结合Pillow、matplotlib和OpenCV实现图片读取

使用Pillow库 matplotlib是一个绘图库&#xff0c;经常用于数据可视化&#xff0c;但它也可以用来展示图片。 from PIL import Image# 读取图片 image Image.open(.jpg)# 展示图片 image.show()使用OpenCV库 OpenCV是一个强大的计算机视觉和机器学习库。它不仅提供了大量的图像…
阅读更多...
masterGo 的设计网站介绍

masterGo 的设计网站介绍

https://mastergo.com/files/home 这个网站是一个设计图片的网站 ui设计方面的网站 有很多优秀的资源 比如App设计 可以直接用的图片 和设计模板 也可以像ps 一样 设计自己的图片或者ui图 适合前端和ui开发者使用 可以丰富自己的审美观
阅读更多...
Kubernetes示例yaml：1. service-deployment.yaml

Kubernetes示例yaml：1. service-deployment.yaml

service-deployment.yaml 示例 apiVersion: apps/v1 kind: Deployment metadata:name: example-plusnamespace: aaaalabels:app: example-prdapp_unit: AAAA-EXAMPLE spec:replicas: 2selector:matchLabels:app: example-prdtemplate:metadata:labels:app: example-prdapp_uni…
阅读更多...
gin语言基础学习--会话控制（下）

gin语言基础学习--会话控制（下）

练习 模拟实现权限验证中间件 有2个路由&#xff0c;/cookie和/home/cookie用于设置cookiehome是访问查看信息的请求在请求home之前&#xff0c;先跑中间件代码&#xff0c;检验是否存在cookie 访问home&#xff0c;会显示错误&#xff0c;因为权限校验未通过 package mainim…
阅读更多...
【CXL协议-ARB/MUX层（5）】

【CXL协议-ARB/MUX层（5）】

5.0 Compute Express Link ARB/MUX 前言&#xff1a; 在CXL协议中&#xff0c;ARB/MUX层&#xff08;Arbitration/Multiplexer layer&#xff09;是负责管理资源共享和数据通路选择的一层。CXL协议包含了几个子协议&#xff0c;主要有CXL.io、CXL.cache 和 CXL.memory。ARB/MU…
阅读更多...
2024年福建事业单位招聘详细流程

2024年福建事业单位招聘详细流程

2024年福建事业单位招聘详细流程&#xff0c;速速查收&#xff01;
阅读更多...
Windows安装tomcat，以服务的方式管理，如何设置虚拟内存

Windows安装tomcat，以服务的方式管理，如何设置虚拟内存

之前工作中&#xff0c;部署tomcat都是使用Linux服务器&#xff0c;最近遇到个客户&#xff0c;提供的服务器是Windows server&#xff0c;并且需要通过服务的方式管理tomcat&#xff1b;以自己多年的码农经验&#xff0c;感觉应该没有问题&#xff0c;结果啪啪打脸了&#xf…
阅读更多...
【实现100个unity特效之7】unity 3d实现各种粒子效果

【实现100个unity特效之7】unity 3d实现各种粒子效果

文章目录 先看最终效果下雨效果萤火虫和火花四溅的效果 3d下雨粒子效果涟漪效果雨滴和涟漪效果结合水花效果雨滴涟漪水花结合问题雾气效果萤火虫火花效果萤火虫和火花效果结合其他特效爆炸、闪电、火焰、雷雨特效&#xff08;2023/7/5更新&#xff09;源码完结 先看最终效果 下…
阅读更多...
使用Nginx1.25.4版本做负载均衡、搭建Nacos2.3.0服务集群

使用Nginx1.25.4版本做负载均衡、搭建Nacos2.3.0服务集群

关于使用版本问题上&#xff0c;其实小白更喜欢使用新的版本&#xff0c;因为新的版本功能更多&#xff0c;肯定优化方面不言而喻&#xff0c;懂得都懂&#xff0c;但是新的版本&#xff0c;肯定使用起来更加的速度&#xff0c;性能&#xff0c;也是不言而喻的啊&#xff0c;那…
阅读更多...
【学海拾贝】| 关于Python的 PEP 484规则了解：类型提示，函数注解

【学海拾贝】| 关于Python的 PEP 484规则了解：类型提示，函数注解

在实际的工厂在实际的工程代码的开发中&#xff0c;常常可以碰到这种情况 上网查了之后发现这是PEP484规则~ 文章目录 1 Type Hints for Variables&#xff08;变量在这里插入图片描述2 Function Annotations&#xff08;函数注解&#xff09;3 Type Checking Tools&#xff08…
阅读更多...
window下迁移SVN仓库到新的windows服务器

window下迁移SVN仓库到新的windows服务器

一、背景 一个基于 Windows 的 SVN 服务器&#xff0c;用于管理团队的代码库。该 SVN 仓库托管着公司的软件项目&#xff0c;包括多个分支和版本的代码。我们的团队规模约为 50 人&#xff0c;分布在不同的地理位置&#xff0c;他们都依赖 SVN 仓库来进行代码版本控制和协作开…
阅读更多...
ETL工具-nifi干货系列 第四讲 Avro schema 序列化框架

ETL工具-nifi干货系列 第四讲 Avro schema 序列化框架

一、在使用nifi的过程中会使用到遇到avro schema、avro data、avroReader、avroWriter等&#xff0c;所以本节课和大家一起学习下avro相关知识。 二、什么是Avro Apache Avro是hadoop中的一个子项目&#xff0c;也是一个数据序列化系统&#xff0c;其数据最终以二进制格式&…
阅读更多...
ZnO非线性电阻片的老化机理生产厂家

ZnO非线性电阻片的老化机理生产厂家

金属氧化物限压器通常不带串联间隙,因此工作电压将长期作用在限压器内的电阻片上&#xff0c;长期有泄漏电流流过。对于工频电压,电流中包括一定分量的阻性电流。虽然阻性电流幅值相对于容性电流要小,但有可能随时间逐渐增加,并导致功率损耗的增加&#xff0c;即ZnO非线性电阻存…
阅读更多...
Django 仿博客园练习

Django 仿博客园练习

数据库搭建 部分功能介绍 【一】注册 &#xff08;1&#xff09;效果显示、简单简介 主要亮点 结合了layui和forms组件默认头像可以随着性别的选择发生改变自定义头像可以实时更新显示forms组件报错信息可以局部刷新显示在对应框体下面 没有直接使用layui的前端验证后端验证…
阅读更多...
Flutter（踩坑）之Android sdkmanager tool not found

Flutter（踩坑）之Android sdkmanager tool not found

D:\Flutter\flutter\bin\flutter.bat doctor --verbose [√] Flutter (Channel stable, v1.2.1, on Microsoft Windows [Version 10.0.22631.3296], locale zh-CN)• Flutter version 1.2.1 at D:\Flutter\flutter• Framework revision 8661d8aecd (5 years ago), 2019-02-14 …
阅读更多...
1.0 html（1）

1.0 html（1）

html 一、基本介绍 1、定义&#xff1a;html是一种超文本标记语言&#xff0c;也是一种标识性语言&#xff08;不是编程语言&#xff09; 标记&#xff1a;记号&#xff08;绰号&#xff09; 超文本&#xff1a;就是页面内容可以包含图片、链接&#xff0c;音乐&#xff0c…
阅读更多...
OC 技术 苹果内购

OC 技术 苹果内购

一直觉得自己写的不是技术&#xff0c;而是情怀&#xff0c;一个个的教程是自己这一路走来的痕迹。靠专业技能的成功是最具可复制性的&#xff0c;希望我的这条路能让你们少走弯路&#xff0c;希望我能帮你们抹去知识的蒙尘&#xff0c;希望我能帮你们理清知识的脉络&#xff0…
阅读更多...
RHCE 补充：判断服务状态

RHCE 补充：判断服务状态

内容补充&#xff1a;判断服务状态 systemctl 命令 系统控制管理命令工具 常用指令 1、启动 systemctl start 程序名 若要启动多个程序名&#xff0c;使用空格隔开&#xff0c;下同 2、重启&#xff1a;类似主机先断电再启动的一个状态 systemctl restart 程序名 3、停…
阅读更多...
最新文章

Copyright @ 2022~2023