面包芯语

Linux内核性能架构：perf_event

Linux阅码场 2022-10-11 08:00
精密双向电流感应放大器设计方案 【有奖直播】提升毫米波信号测试精度
作者简介：

荣涛，csdn博主。

组件概述

Linux性能子系统在性能分析中非常有用。以下显示了这篇文章中的perf子系统componenet 。

“ perf”是可用于执行性能分析的用户程序。

仅暴露给用户空间的系统调用perfeventopen返回一个perf事件fd。该系统调用没有glibc包装器。更多信息可以在手册页中阅读。此功能是最复杂的功能之一。

“ perf_event”是内核中的核心结构。性能事件有几种类型，例如跟踪点，软件，硬件。

我们还可以通过perf event fd将eBPF程序附加到trae事件。

抽象层

以下显示了perf的抽象层。

每个类型的性能事件都有一个对应的PMU（性能监视单元）。例如，跟踪点pmu具有以下pmu。

  1. static struct pmu perf_tracepoint = {
    1. .task_ctx_nr = perf_sw_context,
    2. .event_init = perf_tp_event_init,
    3. .add = perf_trace_add,
    4. .del = perf_trace_del,
    5. .start = perf_swevent_start,
    6. .stop = perf_swevent_stop,
    7. .read = perf_swevent_read,
  2. };


与硬件相关的PMU具有与arch-spec有关的抽象结构，例如'struct x86_pmu'。与硬件相关的结构将读取/写入性能监视器MSR。

每个PMU都通过调用“ perf_pmu_register”进行注册。

性能事件上下文

性能可以监视cpu相关事件和任务相关事件。他们两个都可以有几个受监视的事件。因此，我们需要一个上下文来连接事件。这是“ perf_event_context”。

有两种上下文，软件和硬件，定义如下：

  1.     enum perf_event_task_context {
  2.         perf_invalid_context = -1,
  3.         perf_hw_context = 0,
  4.         perf_sw_context,
  5.         perf_nr_task_contexts,
  6.     };

对于CPU级别，上下文定义为“ perf_cpu_context”，并在“ struct pmu”中定义为percpu变量。

  1.     struct pmu {
  2.         ...
  3.         struct perf_cpu_context __percpu *pmu_cpu_context;
  4.     };


如果PMU是相同类型，则它们将共享一个“ struct perf_cpu_context”。

  1.    int perf_pmu_register(struct pmu *pmu, const char *name, int type)
  2.     {
  3.         int cpu, ret, max = PERF_TYPE_MAX;

  5.         mutex_lock(&pmus_lock);
  6.         ...
  7.         pmu->pmu_cpu_context = find_pmu_context(pmu->task_ctx_nr);
  8.         if (pmu->pmu_cpu_context)
  9.             goto got_cpu_context;

  11.         ret = -ENOMEM;
  12.         pmu->pmu_cpu_context = alloc_percpu(struct perf_cpu_context);
  13.         if (!pmu->pmu_cpu_context)
  14.             goto free_dev;

  16.         for_each_possible_cpu(cpu) {
  17.             struct perf_cpu_context *cpuctx;

  19.             cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
  20.             __perf_event_init_context(&cpuctx->ctx);
  21.             lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);
  22.             lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);
  23.             cpuctx->ctx.pmu = pmu;
  24.             cpuctx->online = cpumask_test_cpu(cpu, perf_online_mask);

  26.             __perf_mux_hrtimer_init(cpuctx, cpu);

  28.             cpuctx->heap_size = ARRAY_SIZE(cpuctx->heap_default);
  29.             cpuctx->heap = cpuctx->heap_default;
  30.         }

  32.     ...
  33.     }

下图显示了此帖子中的相关结构。


对于任务级别，“ task_struct”具有如下定义的指针数组：

  1.     struct task_struct {
  2.         struct perf_event_context    *perf_event_ctxp[perf_nr_task_contexts];
  3.     };

下图显示了相关结构，也来自于该帖子。


CPU在线时将触发CPU级性能事件。但是对于任务级别的perf事件，只能通过运行任务来触发它。“ perf_cpu_context”的task_ctx包含当前正在运行的任务的perf上下文。

性能事件上下文时间表

性能的一项工作是安排任务的perf_event_context的进出时间。

下图显示了与性能相关的任务计划输入和输出功能。

最后，将调用PMU的add和del回调。让我们以跟踪点为例。add回调是“ perf_trace_add”，而del回调是“ perf_trace_add”。

          int perf_trace_add(struct perf_event *p_event, int flags)
  1.     {
  2.         struct trace_event_call *tp_event = p_event->tp_event;

  4.         if (!(flags & PERF_EF_START))
  5.             p_event->hw.state = PERF_HES_STOPPED;

  7.         /*
  8.         * If TRACE_REG_PERF_ADD returns false; no custom action was performed
  9.         * and we need to take the default action of enqueueing our event on
  10.         * the right per-cpu hlist.
  11.         */
  12.         if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_ADD, p_event)) {
  13.             struct hlist_head __percpu *pcpu_list;
  14.             struct hlist_head *list;

  16.             pcpu_list = tp_event->perf_events;
  17.             if (WARN_ON_ONCE(!pcpu_list))
  18.                 return -EINVAL;

  20.             list = this_cpu_ptr(pcpu_list);
  21.             hlist_add_head_rcu(&p_event->hlist_entry, list);
  22.         }

  24.         return 0;
  25.     }

  27.     void perf_trace_del(struct perf_event *p_event, int flags)
  28.     {
  29.         struct trace_event_call *tp_event = p_event->tp_event;

  31.         /*
  32.         * If TRACE_REG_PERF_DEL returns false; no custom action was performed
  33.         * and we need to take the default action of dequeueing our event from
  34.         * the right per-cpu hlist.
  35.         */
  36.         if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_DEL, p_event))
  37.             hlist_del_rcu(&p_event->hlist_entry);
  38.     }

“ perf_event”将被添加或删除到“ tp_event-> perf_events”列表中。

perf_event_open流

  1.     perf_event_open
  2.         ->perf_copy_attr
  3.         ->get_unused_fd_flags(fd)
  4.         ->perf_event_alloc
  5.             ->perf_init_event
  6.                 ->perf_try_init_event
  7.                     ->pmu->event_init()
  8.         ->find_get_context
  9.         ->perf_install_in_context
  10.             ->__perf_install_in_context
  11.                 ->add_event_to_ctx
  12.                     ->list_add_event
  13.                     ->perf_group_attach
  14.             ->add_event_to_ctx
  15.         ->fd_install

perf_event_open将调用'pmu-> event_init'来初始化事件。并将perf_event添加到perf_event_context中。

性能跟踪事件

回顾跟踪点PMU的定义。

  1.     static struct pmu perf_tracepoint = {
  2.         .task_ctx_nr    = perf_sw_context,

  4.         .event_init    = perf_tp_event_init,
  5.         .add        = perf_trace_add,
  6.         .del        = perf_trace_del,
  7.         .start        = perf_swevent_start,
  8.         .stop        = perf_swevent_stop,
  9.         .read        = perf_swevent_read,
  10.     };

让我们尝试看一下perf子系统如何监视跟踪点事件。

性能事件初始化

称为“ perf_tp_event_init”。

  1. perf_tp_event_init
  2.     ->perf_trace_init
  3.         ->perf_trace_event_init
  4.             ->perf_trace_event_reg
  5.                 ->tp_event->class->reg(TRACE_REG_PERF_REGISTER)

'perf_trace_init'将找到指定的跟踪点。

“ perf_trace_event_reg”将分配并初始化“ tp_event_perf_events”列表。并使用TRACE_REG_PERF_REGISTER调用“ tp_event-> class-> reg”。

  1. static int perf_trace_event_reg(struct trace_event_call *tp_event,
  2.                 struct perf_event *p_event)
  3. {
  4.     struct hlist_head __percpu *list;
  5.     int ret = -ENOMEM;
  6.     int cpu;

  8.     p_event->tp_event = tp_event;
  9.     if (tp_event->perf_refcount++ > 0)
  10.         return 0;

  12.     list = alloc_percpu(struct hlist_head);
  13.     if (!list)
  14.         goto fail;

  16.     for_each_possible_cpu(cpu)
  17.         INIT_HLIST_HEAD(per_cpu_ptr(list, cpu));

  19.     tp_event->perf_events = list;

  21.     ...
  22.     ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL);
  23.     if (ret)
  24.         goto fail;

  26.     total_ref_count++;
  27.     return 0;
  28.     ...
  29. }

“ tp_event_> class-> reg”回调为“ trace_event_reg”。

  1.    int trace_event_reg(struct trace_event_call *call,
  2.                 enum trace_reg type, void *data)
  3.     {
  4.         struct trace_event_file *file = data;

  6.         WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
  7.         switch (type) {
  8.         ...

  10.     #ifdef CONFIG_PERF_EVENTS
  11.         case TRACE_REG_PERF_REGISTER:
  12.             return tracepoint_probe_register(call->tp,
  13.                             call->class->perf_probe,
  14.                             call);
  15.         case TRACE_REG_PERF_UNREGISTER:
  16.             tracepoint_probe_unregister(call->tp,
  17.                             call->class->perf_probe,
  18.                             call);
  19.             return 0;
  20.         case TRACE_REG_PERF_OPEN:
  21.         case TRACE_REG_PERF_CLOSE:
  22.         case TRACE_REG_PERF_ADD:
  23.         case TRACE_REG_PERF_DEL:
  24.             return 0;
  25.     #endif
  26.         }
  27.         return 0;
  28.     }

我们可以看到'call-> class-> perf_probe'将被注册到跟踪点。从我的帖子。我们知道这个“ perf_probe”是“ perf_trace _ ## call”。


  1. static notrace void                           
  2.     perf_trace_##call(void *__data, proto)
  3.     {                                    
  4.         struct trace_event_call *event_call = __data;            
  5.         struct trace_event_data_offsets_##call __maybe_unused __data_offsets;
  6.         struct trace_event_raw_##call *entry;
  7.         struct pt_regs *__regs;                        
  8.         u64 __count = 1;                        
  9.         struct task_struct *__task = NULL;                
  10.         struct hlist_head *head;                    
            int __entry_size;                        
  11.         int __data_size;                        
  12.         int rctx;                            
  13.                                         
  14.         __data_size = trace_event_get_offsets_##call(&__data_offsets, args);
  15.                                         
  16.         head = this_cpu_ptr(event_call->perf_events);            
  17.         if (!bpf_prog_array_valid(event_call) &&            
  18.             __builtin_constant_p(!__task) && !__task &&            
  19.             hlist_empty(head))                        
                return;                            
  20.                                         
  21.         __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
  22.                     sizeof(u64));                
  23.         __entry_size -= sizeof(u32);                    
  24.                                         
  25.         entry = perf_trace_buf_alloc(__entry_size, &__regs, &rctx);    
  26.         if (!entry)                            
  27.             return;                            
  28.                                         
  29.         perf_fetch_caller_regs(__regs);                    
  30.                                         
  31.         tstruct
  32.                                         
  33.         { assign; }                            
  34.                                         
  35.         perf_trace_run_bpf_submit(entry, __entry_size, rctx,        
  36.                     event_call, __count, __regs,        
  37.                     head, __task);            
  38.     }

如果“ event_call-> perf_events”为空，则表示没有任何当前的perf_event添加到该跟踪点。这是'perf_event_open'初始化perf_event时的默认状态。

性能事件添加

在CPU中调度任务时，将调用'pmu-> add'，并将'perf_event'链接到'event_call-> perf_events'链接列表。

性能事件

从CPU调度任务后，将调用“ pmu-> del”，并且将从“ event_call-> perf_events”链接列表中删除“ perf_event”。

性能事件触发器

如果'event_call-> perf_events'不为空，则将调用'perf_trace_run_bpf_submit'。如果没有附加eBPF程序，则将调用“ perf_tp_event”。

  1.     void perf_tp_event(u16 event_type, u64 count,
                1. void *record, int entry_size,
  2.             struct pt_regs *regs, struct hlist_head *head, int rctx,
  3.             struct task_struct *task)
  4.     {
  5.         struct perf_sample_data data;
  6.         struct perf_event *event;

  8.         struct perf_raw_record raw = {
  9.             .frag = {
  10.                 .size = entry_size,
  11.                 .data = record,
  12.             },
  13.         };

  15.         perf_sample_data_init(&data, 0, 0);
  16.         data.raw = &raw;

  18.         perf_trace_buf_update(record, event_type);

  20.         hlist_for_each_entry_rcu(event, head, hlist_entry) {
  21.             if (perf_tp_event_match(event, &data, regs))
  22.                 perf_swevent_event(event, count, &data, regs);
  23.         }

  25.         ...
  26.         perf_swevent_put_recursion_context(rctx);
  27.     }

对于“ event_call-> perf_events”列表中的每个“ perf_event”。它调用perf_swevent_event触发性能事件。

  1.    static void perf_swevent_event(struct perf_event *event,
  2.                     u64 nr,struct perf_sample_data *data,
  3.                     struct pt_regs *regs)
  4.     {
  5.         struct hw_perf_event *hwc = &event->hw;

  7.         local64_add(nr, &event->count);

  9.         if (!regs)
  10.             return;

  12.         if (!is_sampling_event(event))
  13.             return;

  15.         if ((event->attr.sample_type & PERF_SAMPLE_PERIOD)
  16.             && !event->attr.freq) {
  17.             data->period = nr;
  18.             return perf_swevent_overflow(event, 1, data, regs);
  19.         } else
  20.             data->period = event->hw.last_period;

  22.         if (nr == 1 && hwc->sample_period == 1 &&
  23.             !event->attr.freq)
  24.             return perf_swevent_overflow(event, 1, data, regs);

  26.         if (local64_add_negative(nr, &hwc->period_left))
  27.             return;

  29.         perf_swevent_overflow(event, 0, data, regs);
  30.     }   
  31.     static void perf_swevent_event(struct perf_event *event,
  32.                     u64 nr,struct perf_sample_data *data,
  33.                     struct pt_regs *regs)
  34.     {
  35.         struct hw_perf_event *hwc = &event->hw;

  37.         local64_add(nr, &event->count);

  39.         if (!regs)
  40.             return;

  42.         if (!is_sampling_event(event))
  43.             return;

  45.         if ((event->attr.sample_type & PERF_SAMPLE_PERIOD)
  46.  && !event->attr.freq) {
  47.             data->period = nr;
  48.             return perf_swevent_overflow(event, 1, data, regs);
  49.         } else
  50.             data->period = event->hw.last_period;

  52.         if (nr == 1 && hwc->sample_period == 1 
  53.             && !event->attr.freq)
  54.             return perf_swevent_overflow(event, 1, data, regs);

  56.         if (local64_add_negative(nr, &hwc->period_left))
  57.             return;

  59.         perf_swevent_overflow(event, 0, data, regs);
  60.     }

'perf_swevent_event'添加'event-> count'。如果事件未采样，则仅返回。Tis是性能计数模式。如果perf_event在样本模式下，则需要复制跟踪点数据。以下是呼叫链。

  1. perf_swevent_overflow
  2.     ->__perf_event_overflow->event
  3.         ->overflow_handler(perf_event_output).

软件性能事件

软件PMU定义如下：

  1.     static struct pmu perf_swevent = {
  2.         .task_ctx_nr    = perf_sw_context,

  4.         .capabilities    = PERF_PMU_CAP_NO_NMI,

  6.         .event_init    = perf_swevent_init,
  7.         .add        = perf_swevent_add,
  8.         .del        = perf_swevent_del,
  9.         .start        = perf_swevent_start,
  10.         .stop        = perf_swevent_stop,
  11.         .read        = perf_swevent_read,
  12.     };

性能事件初始化

“ perf_swevent_init”将被调用。它称为“ swevent_hlist_get”

  1.     static int perf_swevent_init(struct perf_event *event)
  2.     {
  3.         u64 event_id = event->attr.config;

  5.         if (event->attr.type != PERF_TYPE_SOFTWARE)
  6.             return -ENOENT;

  8.         /*
  9.         * no branch sampling for software events
  10.         */
  11.         if (has_branch_stack(event))
  12.             return -EOPNOTSUPP;

  14.         switch (event_id) {
  15.         case PERF_COUNT_SW_CPU_CLOCK:
  16.         case PERF_COUNT_SW_TASK_CLOCK:
  17.             return -ENOENT;

  19.         default:
  20.             break;
  21.         }

  23.         if (event_id >= PERF_COUNT_SW_MAX)
  24.             return -ENOENT;

  26.         if (!event->parent) {
  27.             int err;

  29.             err = swevent_hlist_get();
  30.             if (err)
  31.                 return err;

  33.             static_key_slow_inc(&perf_swevent_enabled[event_id]);
  34.             event->destroy = sw_perf_event_destroy;
  35.         }

  37.         return 0;
  38.     }

这将创建一个percpu'swhash-> swevent_hlist'列表。还要将perf_swevent_enabled [event_id]设置为true。

性能事件添加

'perf_swevent_add'将perf_event添加到percpu哈希列表中。

  1.     static int perf_swevent_add(struct perf_event *event, int flags)
  2.     {
  3.         struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
  4.         struct hw_perf_event *hwc = &event->hw;
  5.         struct hlist_head *head;

  7.         if (is_sampling_event(event)) {
  8.             hwc->last_period = hwc->sample_period;
  9.             perf_swevent_set_period(event);
  10.         }

  12.         hwc->state = !(flags & PERF_EF_START);

  14.         head = find_swevent_head(swhash, event);
  15.         if (WARN_ON_ONCE(!head))
  16.             return -EINVAL;

  18.         hlist_add_head_rcu(&event->hlist_entry, head);
  19.         perf_event_update_userpage(event);

  21.         return 0;
  22.     }

性能事件

'perf_swevent_del'从哈希列表中删除。

  1.     static void perf_swevent_del(struct perf_event *event, int flags)
  2.     {
  3.         hlist_del_rcu(&event->hlist_entry);
  4.     }


性能事件触发器

以任务开关为例。

“ perf_sw_event_sched”将被调用。

  1.     static inline void perf_event_task_sched_out(struct task_struct *prev,
  2.                             struct task_struct *next)
  3.     {
  4.         perf_sw_event_sched(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 0);

  6.         if (static_branch_unlikely(&perf_sched_events))
  7.             __perf_event_task_sched_out(prev, next);
  8.     }

在perf_event_task_sched_out-> _perf_sw_event-> do_perf_sw_event调用链之后。

  1.     static void do_perf_sw_event(enum perf_type_id type, u32 event_id,
  2.                         u64 nr,
  3.                         struct perf_sample_data *data,
  4.                         struct pt_regs *regs)
  5.     {
  6.         struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
  7.         struct perf_event *event;
  8.         struct hlist_head *head;

  10.         rcu_read_lock();
  11.         head = find_swevent_head_rcu(swhash, type, event_id);
  12.         if (!head)
  13.             goto end;

  15.         hlist_for_each_entry_rcu(event, head, hlist_entry) {
  16.             if (perf_swevent_match(event, type, event_id, data, regs))
  17.                 perf_swevent_event(event, nr, data, regs);
  18.         }
  19.     end:
  20.         rcu_read_unlock();
  21.     }

如我们所见，它最终会调用“ perf_swevent_event”来触发事件。

硬件性能事件

硬件PMU之一定义如下：

  1.     static struct pmu pmu = {
  2.         .pmu_enable        = x86_pmu_enable,
  3.         .pmu_disable        = x86_pmu_disable,

  5.         .attr_groups        = x86_pmu_attr_groups,

  7.         .event_init        = x86_pmu_event_init,

  9.         .event_mapped        = x86_pmu_event_mapped,
  10.         .event_unmapped        = x86_pmu_event_unmapped,

  12.         .add            = x86_pmu_add,
  13.         .del            = x86_pmu_del,
  14.         .start            = x86_pmu_start,
  15.         .stop            = x86_pmu_stop,
  16.         .read            = x86_pmu_read,

  18.         .start_txn        = x86_pmu_start_txn,
  19.         .cancel_txn        = x86_pmu_cancel_txn,
  20.         .commit_txn        = x86_pmu_commit_txn,

  22.         .event_idx        = x86_pmu_event_idx,
  23.         .sched_task        = x86_pmu_sched_task,
  24.         .task_ctx_size          = sizeof(struct x86_perf_task_context),
  25.         .swap_task_ctx        = x86_pmu_swap_task_ctx,
  26.         .check_period        = x86_pmu_check_period,

  28.         .aux_output_match    = x86_pmu_aux_output_match,
  29.     };

硬件性能事件非常复杂，因为它将与硬件交互。这里不会深入介绍硬件。

性能事件初始化

  1.     x86_pmu_event_init
  2.         ->__x86_pmu_event_init
  3.             ->x86_reserve_hardware
  4.             ->x86_pmu.hw_config()
  5.         ->validate_event


此处的“ x86_pmu”是基于arch规范的PMU结构。

性能事件添加

x86_pmu_add->收集事件->-> x86_pmu.schedule_events（）-> x86_pmu.add

'collect_events'集

  1.     cpuc->event_list[n] = leader;

性能事件

x86_pmu_del将删除“ cpuc-> event_list”中的事件。

性能事件触发器

触发硬件事件时，它将触发NMI中断。此处理程序是“ perf_event_nmi_handler”。

  1.    static int
  2.     perf_event_nmi_handler(unsigned int cmd, struct pt_regs *regs)
  3.     {
  4.         u64 start_clock;
  5.         u64 finish_clock;
  6.         int ret;

  8.         /*
  9.         * All PMUs/events that share this PMI handler should make sure to
  10.         * increment active_events for their events.
  11.         */
  12.         if (!atomic_read(&active_events))
  13.             return NMI_DONE;

  15.         start_clock = sched_clock();
  16.         ret = x86_pmu.handle_irq(regs);
  17.         finish_clock = sched_clock();

  19.         perf_sample_event_took(finish_clock - start_clock);

  21.         return ret;
  22.     }

以Taks'x86_pmu.handle_irq'= x86_pmu_handle_irq为例。

  1.     for (idx = 0; idx < x86_pmu.num_counters; idx++) {
  2.         if (!test_bit(idx, cpuc->active_mask))
  3.             continue;

  5.         event = cpuc->events[idx];

  7.         val = x86_perf_event_update(event);
  8.         if (val & (1ULL << (x86_pmu.cntval_bits - 1)))
  9.             continue;

  11.         /*
  12.         * event overflow
  13.         */
  14.         handled++;
  15.         perf_sample_data_init(&data, 0, event->hw.last_period);

  17.         if (!x86_perf_event_set_period(event))
  18.             continue;

  20.         if (perf_event_overflow(event, &data, regs))
  21.             x86_pmu_stop(event, 0);
  22.     }

在这里，我们可以看到它对“ cpuc”进行了迭代，以查找触发该中断的事件。

登录阅读全文
免责声明： 该内容由专栏作者授权发布或作者转载，目的在于传递更多信息，并不代表本网赞同其观点，本站亦不保证或承诺内容真实性等。若内容或图片侵犯您的权益，请及时联系本站删除。侵权投诉联系：  nick.zong@aspencore.com！
Linux阅码场 专业的Linux技术社区和Linux操作系统学习平台，内容涉及Linux内核,Linux内存管理,Linux进程管理,Linux文件系统和IO,Linux性能调优,Linux设备驱动以及Linux虚拟化和云计算等各方各面.
评论
  • 12-11学习笔记
    习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习笔记&记录学习习笔记&记学习学习笔记&记录学习学习笔记&记录学习习笔记&记录学习学习笔记&记录学习学习笔记记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记
    youyeye 2024-12-12 10:13 64浏览
  • RK3588主板/开发板Android12系统APK签名文件生成的方法，干货满满
    本文介绍瑞芯微RK3588主板/开发板Android12系统下，APK签名文件生成方法。触觉智能EVB3588开发板演示，搭载了瑞芯微RK3588芯片，该开发板是核心板加底板设计，音视频接口、通信接口等各类接口一应俱全，可帮助企业提高产品开发效率，缩短上市时间，降低成本和设计风险。工具准备下载Keytool-ImportKeyPair工具在源码：build/target/product/security/系统初始签名文件目录中，将以下三个文件拷贝出来：platform.pem；platform.
    Industio_触觉智能 2024-12-12 10:27 93浏览
  • 「智能家庭关键场景测试」揪出智能电视关键Wi-Fi连线问题
    全球智能电视时代来临这年头若是消费者想随意地从各个通路中选购电视时，不难发现目前市场上的产品都已是具有智能联网功能的智能电视了，可以宣告智能电视的普及时代已到临！Google从2021年开始大力推广Google TV(即原Android TV的升级版)，其他各大品牌商也都跟进推出搭载Google TV操作系统的机种，除了Google TV外，LG、Samsung、Panasonic等大厂牌也开发出自家的智能电视平台，可以看出各家业者都一致地看好这块大饼。智能电视的Wi-Fi连线怎么消失了？智能电
    百佳泰测试实验室 2024-12-12 17:33 90浏览
  • 低成本解决方案,RK3506的应用场景分析!
    RK3506 是瑞芯微推出的MPU产品，芯片制程为22nm，定位于轻量级、低成本解决方案。该MPU具有低功耗、外设接口丰富、实时性高的特点，适合用多种工商业场景。本文将基于RK3506的设计特点，为大家分析其应用场景。RK3506核心板主要分为三个型号，各型号间的区别如下图：​图 1  RK3506核心板处理器型号场景1：显示HMIRK3506核心板显示接口支持RGB、MIPI、QSPI输出，且支持2D图形加速，轻松运行QT、LVGL等GUI，最快3S内开
    万象奥科 2024-12-11 15:42 96浏览
  • 天问Block和Mixly
    天问Block和Mixly是两个不同的编程工具，分别在单片机开发和教育编程领域有各自的应用。以下是对它们的详细比较： 基本定义 天问Block：天问Block是一个基于区块链技术的数字身份验证和数据交换平台。它的目标是为用户提供一个安全、去中心化、可信任的数字身份验证和数据交换解决方案。 Mixly：Mixly是一款由北京师范大学教育学部创客教育实验室开发的图形化编程软件，旨在为初学者提供一个易于学习和使用的Arduino编程环境。 主要功能 天问Block：支持STC全系列8位单片机，32位
    丙丁先生 2024-12-11 13:15 71浏览
  • 服务器系统太复杂?！系统整合测试(SIT)助您轻松应对
    应用环境与极具挑战性的测试需求在服务器制造领域里，系统整合测试(System Integration Test；SIT)是确保产品质量和性能的关键步骤。随着服务器系统的复杂性不断提升，包括：多种硬件组件、操作系统、虚拟化平台以及各种应用程序和服务的整合，服务器制造商面临着更有挑战性的测试需求。这些挑战主要体现在以下五个方面：1. 硬件和软件的高度整合：现代服务器通常包括多个处理器、内存模块、储存设备和网络接口。这些硬件组件必须与操作系统及应用软件无缝整合。SIT测试可以帮助制造商确保这些不同组件
    百佳泰测试实验室 2024-12-12 17:45 90浏览
  • 深入解析J1939-73：车辆诊断通信的标准与应用
    一、SAE J1939协议概述SAE J1939协议是由美国汽车工程师协会（SAE，Society of Automotive Engineers）定义的一种用于重型车辆和工业设备中的通信协议，主要应用于车辆和设备之间的实时数据交换。J1939基于CAN（Controller Area Network）总线技术，使用29bit的扩展标识符和扩展数据帧，CAN通信速率为250Kbps，用于车载电子控制单元（ECU）之间的通信和控制。小北同学在之前也对J1939协议做过扫盲科普【科普系列】SAE J
    北汇信息 2024-12-11 15:45 121浏览
  • 【工程师故事】2024年开发板测评与多项目探索总结
    首先在gitee上打个广告：ad5d2f3b647444a88b6f7f9555fd681f.mp4 · 丙丁先生/香河英茂工作室中国 - Gitee.com丙丁先生 (mr-bingding) - Gitee.com2024年对我来说是充满挑战和机遇的一年。在这一年里，我不仅进行了多个开发板的测评，还尝试了多种不同的项目和技术。今天，我想分享一下这一年的故事，希望能给大家带来一些启发和乐趣。 年初的时候，我开始对各种开发板进行测评。从STM32WBA55CG到瑞萨、平头哥和平海的开发板，我都
    丙丁先生 2024-12-11 20:14 86浏览
  • 12-10学习笔记
    习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习笔记&记录学习习笔记&记学习学习笔记&记录学习学习笔记&记录学习习笔记&记录学习学习笔记&记录学习学习笔记记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记录学习学习笔记&记
    youyeye 2024-12-11 17:58 98浏览
  • 半导体划片机在铁氧体划切领域的应用
    铁氧体芯片是一种基于铁氧体磁性材料制成的芯片，在通信、传感器、储能等领域有着广泛的应用。铁氧体磁性材料能够通过外加磁场调控其导电性质和反射性质，因此在信号处理和传感器技术方面有着独特的优势。以下是对半导体划片机在铁氧体划切领域应用的详细阐述： 一、半导体划片机的工作原理与特点半导体划片机是一种使用刀片或通过激光等方式高精度切割被加工物的装置，是半导体后道封测中晶圆切割和WLP切割环节的关键设备。它结合了水气电、空气静压高速主轴、精密机械传动、传感器及自动化控制等先进技术，具有高精度、高
    博捷芯划片机 2024-12-12 09:16 97浏览
  • 康谋方案 | 多源相机数据采集与算法集成测试方案
    在智能化技术快速发展当下，图像数据的采集与处理逐渐成为自动驾驶、工业等领域的一项关键技术。高质量的图像数据采集与算法集成测试都是确保系统性能和可靠性的关键。随着技术的不断进步，对于图像数据的采集、处理和分析的需求日益增长，这不仅要求我们拥有高性能的相机硬件，还要求我们能够高效地集成和测试各种算法。我们探索了一种多源相机数据采集与算法集成测试方案，能够满足不同应用场景下对图像采集和算法测试的多样化需求，确保数据的准确性和算法的有效性。一、相机组成相机一般由镜头(Lens)，图像传感器(Image
    康谋 2024-12-12 09:45 100浏览
  • RE超标整机定位与解决详细流程
    时源芯微——RE超标整机定位与解决详细流程一、 初步测量与问题确认使用专业的电磁辐射测量设备，对整机的辐射发射进行精确测量。确认是否存在RE超标问题，并记录超标频段和幅度。二、电缆检查与处理若存在信号电缆：步骤一：拔掉所有信号电缆，仅保留电源线，再次测量整机的辐射发射。若测量合格：判定问题出在信号电缆上，可能是电缆的共模电流导致。逐一连接信号电缆，每次连接后测量，定位具体哪根电缆或接口导致超标。对问题电缆进行处理，如加共模扼流圈、滤波器，或优化电缆布局和屏蔽。重新连接所有电缆，再次测量
    时源芯微 2024-12-11 17:11 123浏览
我要评论
0
点击右上角，分享到朋友圈 我知道啦
请使用浏览器分享功能 我知道啦