Kai Jellinghaus HurricanKai

QwenQwQ and Virtualization

Created at 2024-12-26 13:07:26 UTC

@ 2024-12-26 13:07:26 UTC

Can you find out for me what the absolute highest performance virtualization tech is, both as an OS or as part of any OS? It's important that I'm not looking for containers - I need good virtualization that can support nested virtualization. Ideally the base OS/Hypervisor has some kind of immutability, but I'd only think about that as a last step. Remember to think in steps, narrowing it down. Be sure to use ResearchAgent to search for up-to-date information. You can yield to me if you want some input on the direction.

Alright, I need to find out what the absolute highest performance virtualization technology is, preferably one that supports nested virtualization and ideally has some immutability features, but that's a secondary concern. I should focus on performance and nested virtualization first.

Riot Rate Limiter

Mix.install([
  {:tesla, "~> 1.4"},
  {:jason, "~> 1.3"},
  {:hackney, "~> 1.18"}
])

Hardware Setup

for each hardware piece we need the following components:

OS
Container runtime
Network Connection to a control plane (or be configured itself to be a control plane)
Potentially storage software
- Ceph looks good here
- Mayastor is new and quite promising
Things to setup:
Network connectivity. Kubernetes services need a way to access a "real" IP

	struct RiotApiClient<T: RegionOrPlatform> {
	inner: Arc<reqwest::Client>,
	ratelimits: tokio::sync::Mutex<Vec<Ratelimit>>,
	region_or_platform: T,
	}

	#[derive(Debug)]
	struct Ratelimit {
	pub current: u32,
	pub limit: u32,

	const std = @import("std");

	current_off: comptime_int,

	const Self = @This();

	pub fn init() Self {
	return .{
	.current_off = 0,
	};

	pub const Instruction = MergeUnions(FillTemplatedAll(union(enum) {
	I__Const: struct { value: u0 },
	F__Const: struct { value: u0 },
	}), IUnOp);

	pub const IUnOp = FillTemplatedAll(union(enum) { I__Clz, I__Ctz, I__PopCnt });

	const std = @import("std");

	const BitWidth = enum { B32, B64 };

	## Fiduciary License Agreement 2.0

	based on the

	## Individual Contributor Exclusive License Agreement

	## (including the Traditional Patent License OPTION)

	Thank you for your interest in contributing to Kai Jellinghaus's Turtler ("We" or "Us").


	// PCG32 randomness
	let all_randomness = vec!["pcg_state", "pcg_inc"];
	const PCG32_MULT: u64 = 0x5851f42d4c957f2du64;

	// note that a >> b and a << b are replaced with a / lit(2.pow(b)) and a * lit(2.pow(b)) respectively

	/* let xorshifted = ((col("pcg_state") / lit(2u64.pow(18))).xor(col("pcg_state"))
	/ lit(2u64.pow(27)))
	.cast(DataType::UInt32);


	#[derive(Clone, serde::Serialize, serde::Deserialize)]
	pub enum AppMessage {
	ConnectionAccepted(lunatic::net::TcpStream),
	TcpStreamCompleted(),
	TcpListenerClosed(),
	}

	#[derive(Clone, serde::Serialize, serde::Deserialize)]
	pub enum ListenerMessage {

	{
	"theme":"chaos_theory",
	"themeLight":"serika",
	"themeDark":"serika_dark",
	"autoSwitchTheme":false,
	"customTheme":false,
	"customThemeColors":[
	"#323437",
	"#e2b714",
	"#e2b714",