Carlo Alberto Ferraris CAFxX

## stack.go
package main

import (
	"fmt"
)

type Stack struct {
	top *Element
	size int
}

## MacroCompression.cpp
/*

  Macro compression transform for LLVM
  ====================================

  Description
  -----------
  This pass identifies duplicated code sequences in the whole module and replaces
  them with equivalent "macros". To keep things simple, macros are defined as
  functions made up of two instructions.

## filemap.c
#ifdef __cplusplus
extern "C" {
#endif

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

## get_first_unique_char.c
#include <stdlib.h>

unsigned char* get_first_unique_char(unsigned char* str, const int len) {
	int pos[256] __attribute__ ((__aligned__(64))), i, p;
	if (str == NULL || len <= 0)
		return NULL;
	for (i=0; i<256; i++)
		pos[i] = -1;
	for (i=0; i<len; i++)
		pos[str[i]] = ( pos[str[i]] == -1 ? i : -2 );

## LLVM-BB-trellis.html
<html><body><script>

const nBB = 256; // number of basic blocks to generate
const nI = 1; // number of instructions per basic block
const nVar = 16; // number of variables defined
const nBr = 16; // number of targets of the switch (for bThreaded==false)
const bThreaded = true; // simulate threaded code (implies nBr=nBB)

var i, vars="";
for (i=0; i<nVar; i++)

## MQReasonCodes.java
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

import com.ibm.mq.constants.CMQC;

public class MQReasonCodes {

	/* Use reflection on the CMQC class to fetch a human readable description of the
	   MQ reason code (e.g. getReason(2035) will return "MQRC_NOT_AUTHORIZED"). If the
	   reason code rc is not found, null will be returned */

## batching.go
type WriteBatcher struct {
    l sync.Mutex
    pending bool
    buf []byte
    err error
}

func (w *WriteBatcher) Write(p []byte) (int, error) {
    w.l.Lock()
    defer w.l.Unlock()

## multitenant_cpu_fairness.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                CAFxX
                / multitenant_cpu_fairness.md
            
            
              Last active
              May 31, 2018 23:08
            
              
                Multi-tenant CPU fairness
              
          
    Multi-tenant CPU fairness

Idea

We want to:

make sure that CPU usage in one container can't significantly affect CPU availability in a different container, regardless if the other container is below or above its CPU shares
minimizing false-positive CPU overload notifications
maximize utilization of unused CPU resources

To this end we would like to find a scheme that progressively gives more freedom in CPU resource consumption to processes that stay below their share of CPU resources (including using more than their allocated shares) while restricting processes that use more than their share of CPU resources, especially if CPU-bound, to use only their allocation.

  
## keybase.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                CAFxX
                / keybase.md
            
            
              Created
              August 13, 2018 07:55
            
              
                keybase.md
              
          
    Keybase proof

I hereby claim:

I am cafxx on github.
I am cafxx (https://keybase.io/cafxx) on keybase.
I have a public key ASCqHgrCYkJIHf07RopDcCeYPXI3kV2St041A11PnDoGPQo

To claim this, I am signing this object:

  
## intern.go
package intern

import (
  "sync"
)

type Pool struct {
  sync.RWMutex
  lookup map[string]string
}
	package main

	import (
	"fmt"
	)

	type Stack struct {
	top *Element
	size int
	}
	/*

	Macro compression transform for LLVM
	====================================

	Description
	-----------
	This pass identifies duplicated code sequences in the whole module and replaces
	them with equivalent "macros". To keep things simple, macros are defined as
	functions made up of two instructions.
	#ifdef __cplusplus
	extern "C" {
	#endif

	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <stdlib.h>

	unsigned char* get_first_unique_char(unsigned char* str, const int len) {
	int pos[256] __attribute__ ((__aligned__(64))), i, p;
	if (str == NULL \|\| len <= 0)
	return NULL;
	for (i=0; i<256; i++)
	pos[i] = -1;
	for (i=0; i<len; i++)
	pos[str[i]] = ( pos[str[i]] == -1 ? i : -2 );
	<html><body><script>

	const nBB = 256; // number of basic blocks to generate
	const nI = 1; // number of instructions per basic block
	const nVar = 16; // number of variables defined
	const nBr = 16; // number of targets of the switch (for bThreaded==false)
	const bThreaded = true; // simulate threaded code (implies nBr=nBB)

	var i, vars="";
	for (i=0; i<nVar; i++)
	import java.lang.reflect.Field;
	import java.lang.reflect.Modifier;

	import com.ibm.mq.constants.CMQC;

	public class MQReasonCodes {

	/* Use reflection on the CMQC class to fetch a human readable description of the
	MQ reason code (e.g. getReason(2035) will return "MQRC_NOT_AUTHORIZED"). If the
	reason code rc is not found, null will be returned */
	type WriteBatcher struct {
	l sync.Mutex
	pending bool
	buf []byte
	err error
	}

	func (w *WriteBatcher) Write(p []byte) (int, error) {
	w.l.Lock()
	defer w.l.Unlock()
	package intern

	import (
	"sync"
	)

	type Pool struct {
	sync.RWMutex
	lookup map[string]string
	}