linux-tracing-timeline.png
linux-tracing-tracing-tech-stack.png Introduction
bpftrace …
# CONFIG_KASAN is not set
CONFIG_RELOCATABLE=y
CONFIG_KEXEC=y
CONFIG_CRASH_DUMP=y
CONFIG_DEBUG_INFO=y
CONFIG_MAGIC_SYSRQ=y
CONFIG_PROC_VMCORE=y
$ sudo apt install kexec-tools makedumpfile crash
$ sudo vi /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="crashkernel …#include <limits.h>
#define INT_MAX_DIV_BY_10 (INT_MAX / 10)
#define INT_MAX_REM_BY_10 (INT_MAX % 10)
#define INT_MIN_DIV_BY_10 (INT_MIN / 10)
#define INT_MIN_REM_BY_10 (INT_MIN % 10)
int myAtoi(char * str){
char *p = str, c;
int s = 1;
int d;
int v = 0;
while (c = *p++) {
if (c == ' ')
continue;
if ((c == '+' || c == '-') && *p >= '0' && *p <= '9') {
if (c …Formular:
dp[i] = MIN( dp[i - coins[j]] + 1 ) (j: [0, coinSize - 1])
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int coinChange(int *coins, int coinSize, int amount)
{
int i, j;
int *dp = calloc(amount + 1, sizeof(int));
int min_so_far;
int prev;
int result;
dp[0] = 0;
for …private constructor
class Foo {
private:
Foo();
}
a get_xxx() method looks like:
static Foo *g_foo = NULL;
Foo *get_foo() {
if (!g_foo)
g_foo = create_foo();
return g_foo;
}
+----------------+ +-----------------+
| Product | | Creator |
+----------------+ +-----------------+
A | |
| +-----------------+
| |+factoryMethod() |
| +-----------------+
| A
| |
| |
+-----------------+ +-----------------+
| ConcreteProduct |<-------<x>| ConcreteCreator |
+-----------------+ +-----------------+
| |
+-----------------+
|+factoryMethod() |
+-----------------+
In Nov. 2015, kernel.org announced that Fastly(a CDN provider) offered CDN service to provide fast download for Linux kernel releases.
Download Linux bundle
$ wget -c --no-check-certificate https://cdn.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/clone.bundle
In Shanghai …
A Min Heap is represented as a binary tree, this binary tree has two characteristics:
class LRUCache(object):
def __init__(self, capacity):
self.__capacity = capacity
self.__dict = {}
# oldest to youngest
self.__list = []
def get(self, key):
if not self.__dict.has_key(key):
return -1
# move key to the tail of list
if key != self.__list[-1]:
self.__list.remove(key)
self.__list.append(key)
return …class MinStack(object):
def __init__(self):
# stack with entries of (value, cur_min)
self.l = []
def push(self, x):
"""
:type x: int
:rtype: nothing
"""
prev_min = self.getMin()
if prev_min == None or prev_min > x:
cur_min = x
else:
cur_min = prev_min
self.l.append((x, cur_min))
def pop(self):
"""
:rtype: nothing
"""
if self.l …Python
class Solution(object):
def __canCompleteCircuit(self, remains, start):
l = remains[start:] + remains[:start]
tank = 0
for val in l:
tank += val
if tank < 0:
return False
return True
def canCompleteCircuit(self, gas, cost):
"""
:type gas: List[int]
:type cost: List[int]
:rtype: int
"""
remains = map(lambda a, b : a …bool isUpperCase(char c)
{
return c >= 'A' && c <= 'Z';
}
bool isLowerCase(char c)
{
return c >= 'a' && c <= 'z';
}
bool isAlpha(char c)
{
return isUpperCase(c) || isLowerCase(c);
}
bool isDigit(char c)
{
return c >= '0' && c <= '9';
}
bool isAlphanumeric(char c)
{
return isAlpha(c) || isDigit(c);
}
bool isCaseInsensitiveEqual(char c1, char …struct QueueNode {
struct TreeNode *val;
struct QueueNode *next;
};
struct Queue {
struct QueueNode *front;
struct QueueNode *rear;
};
int is_empty(struct Queue *q)
{
return !q->front && !q->rear;
}
struct Queue *queue_create(void)
{
struct Queue *q = malloc(sizeof(struct Queue));
q->front = NULL;
q->rear = NULL;
return q;
}
void queue_free(struct Queue *q …$ strace gcc hello_world.c
execve("/usr/bin/gcc", ["gcc", "hello_world.c"], [/* 50 vars */]) = 0
brk(0) = 0x1c35000
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8c4a4d2000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT …#define MAX_NUM_OF_DIGITS 10
#define MAX_VALUE_OF_INT 0x7fffffff
#define MIN_VALUE_OF_INT -0x80000000
int reverse(int x)
{
int digits[MAX_NUM_OF_DIGITS] = { 0 };
int sign = x > 0 ? 1 : 0;
unsigned abs = sign ? x : -x;
unsigned max = sign ? MAX_VALUE_OF_INT : -MIN_VALUE_OF_INT;
unsigned result = 0;
int i = 0;
int num_digits = 0;
while (abs) {
digits[i++] = abs % 10;
abs /= 10 …char *convert(char *s, int numRows)
{
/* string length */
int L = strlen(s);
/* row numbers */
int R = numRows;
/* parameter check */
if (L == 0 || R == 1)
return s;
/* full block numbers */
/*
* one 'block' is defined as:
* 0
* 1 5
* 2 4
* 3
*/
int B = L / (2 * R - 2);
/* remain characters */
int M …/*
* 1. within range [0, i], [beg, end] is the longest substring, and
* [candidate, i] is the possible longer substring.
* 2. extend range to [0, i + 1], if s[i + 1] can be combined with
* [candidate, i] AND if [candidate, i + 1] is longer than [beg, end],
* update [beg, end].
* 3 …#include <stdio.h>
#include <stdlib.h>
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
struct node {
int index;
int value;
};
void list_qsort(struct node **list, int size)
{
struct node *anchor = list[0];
int i = 1;
int j = size - 1;
struct node *tmp …#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"
struct ListNode {
int val;
struct ListNode *next;
};
/*
* [in]
* @nd1: linked list of nodes
* @nd2: linked list of nodes
*
* [out]
* none
*
* [in/out]
* @carry(in): carry value of last sum
* @carry(out): carry value of current sum
*/
static struct …# unbind all keys once config is reloaded
unbind-key -a
# set TERM to screen-256color in tmux
set -g default-terminal "screen-256color"
# reload config file
bind r source-file ~/.tmux.conf; display 'config reloaded'
# list current bind keys
bind ? list-keys
# detach client
bind d detach-client
# switch client
bind p switch-client -p
bind n …#include <pthread.h>
int pthread_create(pthread_t *tidp,
const pthread_attr_t attr,
void *(*start_rtn)(void *),
void *arg);
int pthread_join(pthread_t *tidp, void **rval_ptr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_signal(pthread_cond_t *cond);
" === Vundle Options ===
set nocompatible
filetype off
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle
Plugin 'gmarik/Vundle.vim'
" plugin from http://vim-scripts.org/vim/scripts.html
Plugin 'a.vim'
Plugin 'taglist.vim'
Plugin 'gtags.vim'
" plugin from github repo
Plugin 'godlygeek/tabular'
Plugin 'plasticboy/vim-markdown …+---------------------------------------------------------------------+
| NSTableView: Delegate Object: |
| strong |
| ---------> |
| @property id delegate; @property NSTableView *tableview; |
| <--------- |
| strong |
+---------------------------------------------------------------------+
+----------------------------------------------------------------------------+
| NSTableView: Delegate Object: |
| weak |
| ---------> |
| @property (weak) id delegate; @property NSTableView *tableview; |
| <--------- |
| strong |
+----------------------------------------------------------------------------+
To fully simplify my situation but also clearly show the key points, I use some dummy code to describe this bug.
Considering that we want to let our code execute in following logic:
But to …
We often use time command to measure the executing time of a program. It will print program's real, user and sys time respectively.
However, our commonly used 'time' is just a shell (bash, zsh) built-in command (same kind as 'cd', 'pwd' and etc). In some use cases …
#=> update every 1 second
$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
r b swpd free buff cache si so bi bo in cs us sy id wa
15 0 2852 46686812 279456 1401196 0 0 0 0 0 0 0 0 100 0
16 0 2852 46685192 …bool gpio_is_valid(int number);
int gpio_request(unsigned gpio, const char *label);
void gpio_free(unsigned gpio);
int gpio_direction_input(unsigned gpio);
int gpio_direction_output(unsigned gpio, int value);
int gpio_get_value(unsigned gpio);
void gpio_set_value(unsigned gpio, int value);
int gpio_export(unsigned gpio, bool direction_may_change);
void gpio_unexport(unsigned gpio);
int gpio_to_irq …