amanelis

SELECT l.metric, l.nr AS bytes
     , CASE WHEN is_size THEN pg_size_pretty(nr) END AS bytes_pretty
     , CASE WHEN is_size THEN nr / NULLIF(x.ct, 0) END AS bytes_per_row
FROM  (
   SELECT min(tableoid)        AS tbl      -- = 'public.tbl'::regclass::oid
        , count(*)             AS ct
        , sum(length(t::text)) AS txt_len  -- length in characters
   FROM   {YOUR TABLE} t                     -- provide table name *once*
   ) x
CROSS  JOIN LATERAL (

amanelis

High Performance Redis

In response to this brief blog entry, @antirez tweeted for some documentation on high-performance techniques for Redis. What I present here are general high-performance computing (HPC) techniques. The examples are oriented to Redis. but they work well for any program designed to be single- or worker-threaded and asynchronous (e.g. uses epoll).

The motivation for using these techniques is to maximize performance of our system and services. By isolating work, controlling memory, and other tuning, you can achieve significant reduction in latency and increase in throughput.

My perspective comes from the microcosm of my own bare-metal (vs VM), on-premises deployment. It might not be suitable for all scenarios, especially cloud deployments, as I have little experience with HPC there. After some discussion, maybe this can be adapted as [redis.io documentation](https://redis.io/do

amanelis

package main

import (
	"fmt"
    "github.com/ethereum/go-ethereum/core/rawdb"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/core/state"
    "github.com/ethereum/go-ethereum/rlp"
	"github.com/ethereum/go-ethereum/trie"
	_ "github.com/ethereum/go-ethereum/common"

amanelis

// Here is an extremely simple version of work scheduling for multiple
// processors.
//
// The Problem: 
//  We have a lot of numbers that need to be math'ed. Doing this on one 
//  CPU core is slow. We have 4 CPU cores. We would thus like to use those
//  cores to do math, because it will be a little less slow (ideally
//  4 times faster actually).
//
// The Solution:

amanelis

import numpy as np
import cvxpy as cp
import itertools

# Problem data
global_indices = list(range(4))

# 0 = TOKEN-0
# 1 = TOKEN-1
# 2 = TOKEN-2

amanelis

// SPDX-License-Identifier: MIT

object "Multicall" {
    code {
        // Deploy the contract
        // Store gas token burn cost in zero slot
        sstore(0, 0)
        sstore(1, 0)
        sstore(2, 0)
        datacopy(0x0, dataoffset("MulticallRuntime"), datasize("MulticallRuntime"))

amanelis

# Generate the private and public keys
openssl ecparam -name secp256k1 -genkey -noout | openssl ec -text -noout > key

# Extract the public key and remove the EC prefix 0x04
cat key | grep pub -A 5 | tail -n +2 | tr -d '\n[:space:]:' | sed 's/^04//' > pub

# Extract the private key and remove the leading zero byte
cat key | grep priv -A 3 | tail -n +2 | tr -d '\n[:space:]:' | sed 's/^00//' > priv

# Generate the hash and take the address part

amanelis

package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	neturl "net/url"
	"time"
)

amanelis

# /etc/systemd/system/geth.service

[Unit]
Description=Go Ethereum Client
After=network.target
Wants=network.target

[Service]
User=goeth`
Group=goeth

amanelis

require 'rubygems'
require 'nokogiri'
require 'open-uri'

puts "COVID Vaccine Finder / Fremont, California"

page = Nokogiri::HTML(open(URL))
mDiv = "body > div > div.shadow-sm.p-3.mb-4.rounded > div:nth-child(8) > div"
bDiv = "button"