Hugging Face's logo

Datasets:
froggeric
/
imatrix

Modalities:
Text
Formats:
text
Languages:
English
Size:
10K - 100K
Libraries:
Datasets
Dataset card Viewer Files Community
3
imatrix / code.txt
froggeric's picture
froggeric
Upload code.txt
fc98cf0 verified
raw
history blame
249 kB
move.w #$0100,d0
clr.l d1
move.w #$0400,d4
clr.l d2
move.w #$1000,d3
NotReached:
addi.b #$10,d2
add.w d0,d1
cmp.w d1,d4
bgt.s NotReached
sub.w d2,d1
subi.w #$1000,d3
bpl.s NotReached
move.w d1,d0
swap d0
move.w d3,d0
sep #%00100000 ;8 bit accumulator
ldx #4 ;modifying 5 locations
;
loop lda $ab1234,x ;load
inc a ;increment
sta $ab1234,x ;store
dex
bpl loop ;next
phb ;save current data bank
sep #%00110000 ;8 bit registers
lda #$ab ;target bank
pha ;push it to the stack & pull it...
plb ;into DB, making it the default bank
ldx #4 ;modifying 5 locations
;
loop inc $1234,x ;effectively INC $AB1234,X
dex
bpl loop ;next
;
plb ;restore previous bank
sei ;IRQs off
wai ;wait for interrupt
lda via001 ;start of interrupt handler
#!/bin/bash
TARGET_DIR=("$@")
[ "x$1" == "x" ] && TARGET_DIR=(".")
function confirmDeletion() {
local confirm=""
until [ "x$confirm" == 'xy' ] || [ "x$confirm" == 'xn' ]
do
read -ep " Delete [y/n]: " confirm
confirm=$(echo "$confirm" | tr [:upper:] [:lower:])
done
[ "x$confirm" == 'xy' ]
}
function deleteWithConfirmation() {
for file in "${@}"
do
if rm "$file"; then
echo " OK: $file"
else
echo " FAIL: $file"
fi
done
}
for i in {'*~','a.out','*.o','*.gch','*nppdf32Log*'}
do
echo "Files matching: $i"
FILES=()
while read -rd '' file
do
FILES+=("$file")
echo " $file"
done < <(find "${TARGET_DIR[@]}" -depth -iname "$i" -print0)
if [ "x${FILES[*]}" != "x" ]; then
if confirmDeletion; then
deleteWithConfirmation "${FILES[@]}"
else
echo " Skipping"
fi
fi
done
Return the open file descriptor to the calling function via the eight bit accumulator by overwriting the appropriate register stack frame element:
sep #%00100000 ;select 8 bit accumulator
lda #0 ;clear...
xba ;.B
lda filedes ;get file descriptor, ...
rep #%00100000 ;select 16 bit accumulator &...
sta reg_a,s ;overwrite .C's stack copy
When the accumulator is pulled it will contain the value that was in filedes.
Flag an error by setting the carry bit in SR:
sep #%00100000 ;select 8 bit accumulator
lda reg_sr,s ;stack copy of SR
ora #%00000001 ;set carry bit &...
sta reg_sr,s ;rewrite
Flag a successful operation by clearing the carry bit in SR:
sep #%00100000 ;select 8 bit accumulator
lda reg_sr,s ;stack copy of SR
and #%11111110 ;clear carry bit &...
sta reg_sr,s ;rewrite
class PromptFormat:
botname = "Chatbort"
username = "User"
def __init__(self):
pass
#
def default_system_prompt(self):
raise NotImplementedError
def first_prompt(self):
raise NotImplementedError
def subs_prompt(self):
raise NotImplementedError
def stop_conditions(self, tokenizer):
raise NotImplementedError
def encoding_options(self): # (add_bos, add_eos, encode_special_tokens)
raise NotImplementedError
def print_bot_name(self):
return False
def print_extra_newline(self):
return False
class PromptFormat_raw(PromptFormat):
description = "Model-agnostic mode simulating a raw chatlog"
def __init__(self):
super().__init__()
pass
def default_system_prompt(self):
return \
f"""This is a conversation between a helpful AI assistant named {self.botname} and a """ + \
(f"""user named {self.username}.""" if self.username != "User" else """user.""")
def first_prompt(self):
return \
f"""<|system_prompt|>\n{self.username}: <|user_prompt|>\n{self.botname}:"""
def subs_prompt(self):
return \
f"""{self.username}: <|user_prompt|>\n{self.botname}:"""
def stop_conditions(self, tokenizer):
return \
[self.username + ":",
self.username[0:1] + ":",
self.username.upper() + ":",
self.username.lower() + ":",
tokenizer.eos_token_id]
def encoding_options(self):
return False, False, False
def print_bot_name(self):
return True
########################################################
class PromptFormat_llama(PromptFormat):
description = "Llama-chat, Llama2-chat and Mistral-instruct models"
def __init__(self):
super().__init__()
pass
def default_system_prompt(self):
return \
"""You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. """ + \
"""Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. """ + \
"""Please ensure that your responses are socially unbiased and positive in nature."""
def first_prompt(self):
return \
"""[INST] <<SYS>>\n<|system_prompt|>\n<</SYS>>\n\n<|user_prompt|> [/INST]"""
def subs_prompt(self):
return \
"""[INST] <|user_prompt|> [/INST]"""
def stop_conditions(self, tokenizer):
return \
[tokenizer.eos_token_id]
def encoding_options(self):
return True, False, False
def print_extra_newline(self):
return True
def build_attn_mask(self, batch_size, seq_len, past_len, input_mask, device):
if input_mask is None and seq_len == 1: return None
if isinstance(past_len, tuple):
attn_masks = []
for i in range(len(past_len[1])):
attn_mask = torch.zeros((1, 1, seq_len, past_len[1][i] + seq_len), dtype = torch.float16, device = device)
attn_mask_triu = torch.triu(torch.full((seq_len - 1, seq_len - 1), -65504.))
attn_mask[:, :, : seq_len - 1, past_len[1][i] + 1: past_len[1][i] + seq_len] = attn_mask_triu
if input_mask is not None:
min_mask_width = min(input_mask[i].shape[-1], seq_len + past_len[1][i])
input_mask_part = safe_move_tensor(input_mask[i][:, :min_mask_width], attn_mask.device)
input_mask_part = input_mask_part.unsqueeze(1).unsqueeze(2)
attn_mask[:, :, :, :min_mask_width] = torch.minimum(attn_mask[:, :, :, :min_mask_width], input_mask_part)
attn_masks.append(attn_mask)
return attn_masks
else:
attn_mask = torch.zeros((batch_size, 1, seq_len, past_len + seq_len), dtype = torch.float16, device = device)
attn_mask_triu = torch.triu(torch.full((seq_len - 1, seq_len - 1), -65504.))
attn_mask[:, :, : seq_len - 1, past_len + 1: past_len + seq_len] = attn_mask_triu
if input_mask is not None:
min_mask_width = min(input_mask.shape[-1], seq_len + past_len)
input_mask_part = safe_move_tensor(input_mask[:, :min_mask_width], attn_mask.device)
input_mask_part = input_mask_part.unsqueeze(1).unsqueeze(2)
attn_mask[:, :, :, :min_mask_width] = torch.minimum(attn_mask[:, :, :, :min_mask_width], input_mask_part)
return attn_mask
We have to develop a Java program to calculate the sum of n natural numbers. Sum of natural number N as given as sum = 1+2+3+….+N
Examples:-
1+2+3+4+5 = 15
1+2+3+4+5+6+7+8+9+10 = 55
Procedure to develop a method to find the sum of N natural numbers in Java,
Take the N value.
Declare an iterator variable and initialize it with 1 because natural numbers start with 1.
Add iterator variable value into the sum variable
Increase the value of the iterator variable by 1
Repeat 3 and 4 steps until the number remains greater than the iterator variable
The time complexity of this procedure is O(n).
import java.util.Scanner;
public class NaturalNumberSum {
// method to find sum of N natural numbers
public static int naturalNumberSum(int number){
int i = 1; // iterator variable
// variable to store sum value
int sum = 0;
// loop to repeat the process
while (i<=number) {
// add into sum value
sum = sum + i;
// increase iterator variable
i++;
}
// return sum value
return sum;
}
public static void main(String[] args) {
// declare variables
int number = 0;
int sum = 0;
// create Scanner class object
Scanner scan = new Scanner(System.in);
// read input
System.out.print("Enter N value:: ");
number = scan.nextInt();
// Calculate the sum value
sum = naturalNumberSum(number);
// display result
System.out.println("Sum = "+sum);
// close Scanner class objects
scan.close();
}
}
The output for different test-cases:-
Enter N value:: 5
Sum = 15
Enter N value:: 10
Sum = 55
In this program, we have used a while loop to find the sum of natural numbers in Java. While loop is a pre-test loop where the expression is evaluated then only statements are executed. It uses a test expression to control the loop. Before every iteration of the loop, the test expression is evaluated.
Also See:-
Sum of digits of a number
The sum of even digits in a number
Sum of odd digits in a number
Sum of first & last digit of a number
The Sum of Digits Until Single Digit
We can also use for loop instead of using a while loop. The for loop is also a pre-test loop, where first of all initialization expression is evaluated then the condition is checked and if the condition is true then only the statements of the for loop are executed.
public static int naturalNumberSum(int number){
int sum = 0;
for(int i=1; i<=number; i++)
sum+=i;
return sum;
}
Or,
public static int naturalNumberSum(int number){
int sum = 0;
for(int i=1; ; sum+=i, i++)
if(i>number) return sum;
}
The time complexity of all above methods are O(n).
Sum of Natural Numbers in Java without using the loop
We can also do the same work without using the loop. The formula for this operation,
Sum = n * (n+1) / 2;
Example:-
Sum of first 10 natural numbers = 10*(10+1)/2 = 10*11/2 = 5*11 = 55
It is the best way to find the sum of natural numbers. The time complexity of this method is O(1).
import java.util.Scanner;
public class NaturalNumberSum {
// method to find sum of N natural numbers
public static int naturalNumberSum(int number){
return number*(number+1)/2;
}
public static void main(String[] args) {
// declare variables
int number = 0;
int sum = 0;
// create Scanner class object
Scanner scan = new Scanner(System.in);
// read input
System.out.print("Enter N value:: ");
number = scan.nextInt();
// Calculate the sum value
sum = naturalNumberSum(number);
// display result
System.out.println("Sum = "+sum);
// close Scanner class objects
scan.close();
}
}
Using recursion
We already developed java program to find the sum of the natural number using for loop, or while loop, or without using the loop. Now we will find the same using the recursion technique. In Recursion, We divided the big problems into smaller problems or sub-problems.
Sum of N natural numbers given as 1+2+….+(n-1)+n. So, the problem can be divided as n + ( (n-1) +… + 2 + 1 )
General case for finding the sum of natural number => sum(n) = n + sum(n-1); Similarly, the base case for finding the sum of natural number => sum(0) = 0; or sum(1) = 1;
import
module jtransmissiongatetb;
wire y;
reg a,control;
jtransmissiongate jtgate(y,control,a);
initial
begin
$display ("RESULT\ta\ty");
a = 0; control = 0; # 50; // Initial value is set
if ( y === 1'bz ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
a = 0; control = 1; # 50; // Initial value is set
if ( y === 0 ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
a = 1; control = 0; # 50; // Another value
if ( y === 1'bz ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
a = 1; control = 1; # 50; // Another value
if ( y === 1 ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
end
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
endmodule
module jtransmissiongate(y,control,a);
output y;
input a,control;
wire cbar;
assign cbar = ~control;
nmos n1(y,a,control);
pmos p1(y,a,cbar);
//cmos c1(y,a,control,cbar);
endmodule
module juniversalShiftRegisterTb;
wire [3:0] DATAOUT;
reg clock, reset;
reg [1:0] MODE;
reg [3:0] DATAIN;
juniversalShiftRegister jusr(DATAOUT, clock, reset, MODE, DATAIN);
initial
begin
clock =0; MODE = 2'b00; DATAIN = 4'b0000;
reset = 1; #10; reset = 0; #10;
$display("RSLT\tD == DOUT");
// Start testing Right Shift mode
MODE = 2'b00; reset = 1; #10; reset = 0; #10;
MODE = 2'b01; DATAIN = 4'b0011; #10;
if ( DATAOUT === 4'b1000 ) // look at previous value of DATAOUT as well
$display("PASS\t%p is %p with %p", DATAIN, MODE, DATAOUT);
else
$display("FAIL\t%p is %p with %p", DATAIN, MODE, DATAOUT);
MODE = 2'b01; DATAIN = 4'b0011; #10;
if ( DATAOUT === 4'b1100 ) // look at previous value of DATAOUT as well
$display("PASS\t%p is %p with %p", DATAIN, MODE, DATAOUT);
else
$display("FAIL\t%p is %p with %p", DATAIN, MODE, DATAOUT);
// Start testing Left Shift mode
MODE = 2'b00; reset = 1; #10; reset = 0; #10;
MODE = 2'b10; DATAIN = 4'b0111; #10;
if ( DATAOUT === 4'b0001 ) //
$display("PASS\t%p is %p with %p", DATAIN, MODE, DATAOUT);
else
$display("FAIL\t%p is %p with %p", DATAIN, MODE, DATAOUT);
MODE = 2'b10; DATAIN = 4'b0111; #10;
if ( DATAOUT === 4'b0011 ) //
$display("PASS\t%p is %p with %p", DATAIN, MODE, DATAOUT);
else
$display("FAIL\t%p is %p with %p", DATAIN, MODE, DATAOUT);
// Start testing parallel load mode
MODE = 2'b00; reset = 1; #10; reset = 0; #10;
MODE = 2'b11; DATAIN = 4'b1010; #10;
if ( DATAOUT === 4'b1010 )
$display("PASS\t%p is %p with %p", DATAIN, MODE, DATAOUT);
else
$display("FAIL\t%p is %p with %p", DATAIN, MODE, DATAOUT);
#20;
$finish;
end
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
always #5 clock = ~clock;
endmodule
#!/bin/bash
# use predefined variables to access passed arguments
#echo arguments to the shell
echo $1 $2 $3 ' -> echo $1 $2 $3'
# We can also store arguments from bash command line in special array
args=("$@")
#echo arguments to the shell
echo ${args[0]} ${args[1]} ${args[2]} ' -> args=("$@"); echo ${args[0]} ${args[1]} ${args[2]}'
#use $@ to print out all arguments at once
echo $@ ' -> echo $@'
# use $# variable to print out
# number of arguments passed to the bash script
echo Number of arguments passed: $# ' -> echo Number of arguments passed: $#'
Let’s try executing this script and providing three arguments.
$ ./arguments.sh Bash Scripting Tutorial
The results when we execute this script:
Bash Scripting Tutorial -> echo $1 $2 $3
Bash Scripting Tutorial -> args=("$@"); echo ${args[0]} ${args[1]} ${args[2]}
Bash Scripting Tutorial -> echo $@
Number of arguments passed: 3 -> echo Number of arguments passed: $#
Executing shell commands with bash
The best way to execute a separate shell command inside of a Bash script is by creating a new subshell through the $( ) syntax. Check the example below where we echo the result of running the uname -o command.
#!/bin/bash
# use a subshell $() to execute shell command
echo $(uname -o)
# executing bash command without subshell
echo uname -o
Notice that in the final line of our script, we do not execute the uname command within a subshell, therefore the text is taken literally and output as such.
$ uname -o
GNU/LINUX
$ ./subshell.sh
GNU/LINUX
uname -o
Reading User Input
We can use the read command to read input from the user. This allows a user to interact with a Bash script and help dictate the way it proceeds. Here’s an example:
#!/bin/bash
echo -e "Hi, please type the word: \c "
read word
echo "The word you entered is: $word"
echo -e "Can you please enter two words? "
read word1 word2
echo "Here is your input: \"$word1\" \"$word2\""
echo -e "How do you feel about bash scripting? "
# read command now stores a reply into the default build-in variable $REPLY
read
echo "You said $REPLY, I'm glad to hear that! "
echo -e "What are your favorite colours ? "
# -a makes read command to read into an array
read -a colours
echo "My favorite colours are also ${colours[0]}, ${colours[1]} and ${colours[2]}:-)"
Our Bash script asks multiple questions and then is able to repeat the information back to us through variables and arrays:
$ ./read.sh
Hi, please type the word: Linuxconfig.org
The word you entered is: Linuxconfig.org
Can you please enter two words?
Debian Linux
Here is your input: "Debian" "Linux"
How do you feel about bash scripting?
good
You said good, I'm glad to hear that!
What are your favorite colours ?
blue green black
My favorite colours are also blue, green and black:-)
Bash Trap Command
The trap command can be used in Bash scripts to catch signals sent to the script and then execute a subroutine when they occur. The script below will detect a Ctrl + C interrupt.
#!/bin/bash
# bash trap command
trap bashtrap INT
# bash clear screen command
clear;
# bash trap function is executed when CTRL-C is pressed:
# bash prints message => Executing bash trap subrutine !
bashtrap()
{
echo "CTRL+C Detected !...executing bash trap !"
}
# for loop from 1/10 to 10/10
for a in `seq 1 10`; do
echo "$a/10 to Exit."
sleep 1;
done
echo "Exit Bash Trap Example!!!"
In the output below you can see that we try to Ctrl + C two times but the script continues to execute.
$ ./trap.sh
1/10 to Exit.
2/10 to Exit.
^CCTRL+C Detected !...executing bash trap !
3/10 to Exit.
4/10 to Exit.
5/10 to Exit.
6/10 to Exit.
7/10 to Exit.
^CCTRL+C Detected !...executing bash trap !
8/10 to Exit.
9/10 to Exit.
10/10 to Exit.
Exit Bash Trap Example!!!
Arrays
Bash is capable of storing values in arrays. Check the sections below for two different examples.
Declare simple bash array
This example declares an array with four elements.
#!/bin/bash
#Declare array with 4 elements
ARRAY=( 'Debian Linux' 'Redhat Linux' Ubuntu Linux )
# get number of elements in the array
ELEMENTS=${#ARRAY[@]}
# echo each element in array
# for loop
for (( i=0;i<$ELEMENTS;i++)); do
echo ${ARRAY[${i}]}
done
Executing the script will output the elements of our array:
$ ./arrays.sh
Debian Linux
Redhat Linux
Ubuntu
Linux
Read file into bash array
Rather than filling out all of the elements of our array in the Bash script itself, we can program our script to read input and put it into an array.
#!/bin/bash
# Declare array
declare -a ARRAY
# Link filedescriptor 10 with stdin
exec 10<&0
# stdin replaced with a file supplied as a first argument
exec < $1
let count=0
while read LINE; do
ARRAY[$count]=$LINE
((count++))
done
echo Number of elements: ${#ARRAY[@]}
# echo array's content
echo ${ARRAY[@]}
# restore stdin from filedescriptor 10
# and close filedescriptor 10
exec 0<&10 10<&-
Now let’s execute the script and store four elements in the array by using a file’s contents for input.
$ cat bash.txt
Bash
Scripting
Tutorial
Guide
$ ./bash-script.sh bash.txt
Number of elements: 4
Bash Scripting Tutorial Guide
*** CompressADPCM3 ***
; JoinCode = CompressADPCM3(Source, Length, Destination, JoinCode)
; d0 a0 d0 a1 d1
;
; This function compresses a RAW sample to a given memory. The
; result is a 3bit ADPCM code. The destination buffer must be
; at least (Length+7)/8*3 bytes in size.
;
; Function of the JoinCode: See above.
XDEF _CompressADPCM3
_CompressADPCM3
movem.l d2-d4,-(sp)
move.w d1,d3 ; d3=EstMax
swap d1
move.w d1,d2 ; d2=Delta
bne.s c3_loop
moveq #5,d2
c3_loop moveq #0,d1 ; d1=Shifter
bsr.s c3_byte
lsl.b #3,d1
bsr.s c3_byte
lsl.w #3,d1
bsr.s c3_byte
lsl.w #3,d1
bsr.s c3_byte
lsl.w #3,d1
bsr.s c3_byte
lsl.l #3,d1
bsr.s c3_byte
lsl.l #3,d1
bsr.s c3_byte
lsl.l #3,d1
bsr.s c3_byte
swap d1
move.b d1,(a1)+
rol.l #8,d1
move.b d1,(a1)+
rol.l #8,d1
move.b d1,(a1)+
subq.l #8,d0 ; d0=Counter
bhi.s c3_loop
move.w d2,d0 ; -> d0=JoinCode
swap d0
move.w d3,d0
movem.l (sp)+,d2-d4
rts
c3_byte move.b (a0)+,d4
ext.w d4
asl.w #6,d4
sub.w d3,d4
bpl.s c3_positive
or.b #%100,d1
neg.w d4
c3_positive sub.w d2,d4
bls.s c3_00
sub.w d2,d4
bls.s c3_01
sub.w d2,d4
bls.s c3_10
c3_11 or.b #%11,d1
bra.s c3_00
c3_10 or.b #%10,d1
bra.s c3_00
c3_01 or.b #%01,d1
c3_00 bsr.s adaptive
rts
*** Adaptions-Routine ***
adaptive ; d1 = SignBit + DataBit
move.w d2,d4
lsr.w #1,d4
btst #1,d1
beq.s d3_0
d3_1 btst #0,d1
beq.s d3_10
d3_11 add.w d2,d4
add.w d2,d4
add.w d2,d4
mulu #$6607,d2
bra.s d3_sign
d3_10 add.w d2,d4
add.w d2,d4
mulu #$4D14,d2
bra.s d3_sign
d3_0 btst #0,d1
beq.s d3_00
d3_01 add.w d2,d4
mulu #$3A9F,d2
bra.s d3_sign
d3_00 mulu #$399A,d2
d3_sign btst #2,d1
beq.s d3_add
neg.w d4
d3_add add.w d4,d3
add.l #8192,d2
moveq #14,d4
asr.l d4,d2
rts
END
mov
mov bp, 255
traceloop:
; Evaluate whether sample point is inside or outside the shape:
;
; ( a & ( b | c ) ) | ( b & c ) = 0 <=> voxel overlaps fractal
push bx
mov dx, bx
or dx, cx
and dx, ax
and bx, cx
or dx, bx
pop bx
; Ignore the lower bits or the fractal will be too fine to see
shr dx, 6
jz endtrace
dec bp
jnz traceloop
endtrace:
; BP is 255 - the distance we had to trace
mov dx, bp
not dl
; Plot pixel
mov ds:[di],dl
inc di
// ******************
#include <torch/extension.h>
#include <c10/cuda/CUDAGuard.h>
#include <ATen/cuda/CUDAContext.h>
#include <cuda_runtime.h>module jtransmissiongatetb;
wire y;
reg a,control;
jtransmissiongate jtgate(y,control,a);
initial
begin
$display ("RESULT\ta\ty");
a = 0; control = 0; # 50; // Initial value is set
if ( y === 1'bz ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
a = 0; control = 1; # 50; // Initial value is set
if ( y === 0 ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
a = 1; control = 0; # 50; // Another value
if ( y === 1'bz ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
control = 1; # 50; // Simply change the control signal
control = 0; # 50; // Simply change the control signal
a = 1; control = 1; # 50; // Another value
if ( y === 1 ) // Test for inversion
$display ("PASS \t%d\t%d",a,y);
else
$display ("FAIL \t%d\t%d",a,y);
end
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
endmodule
#include <cuda_fp16.h>
#include <cstdint>
#include <cstdio>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include "config.h"
#include "cuda/pack_tensor.cuh"
#include "cuda/quantize.cuh"
#include "cuda/q_matrix.cuh"
#include "cuda/q_attn.cuh"
#include "cuda/q_mlp.cuh"
#include "cuda/q_gemm.cuh"
#include "cuda/rms_norm.cuh"
#include "cuda/rope.cuh"
#include "cuda/cache.cuh"
#include "cuda/h_gemm.cuh"
#include "cpp/quantize_func.h"
#include "cpp/sampling.h"
#include "cpp/util.h"
// Some decluttering macros
#define TORCH_CHECK_DTYPE(__x, __dtype) TORCH_CHECK((__x).dtype() == torch::__dtype, #__x " is incorrect datatype, must be " #__dtype)
#define TORCH_CHECK_DTYPE_OPT(__x, __dtype) TORCH_CHECK((__x).device().is_meta() || (__x).dtype() == torch::__dtype, #__x " is incorrect datatype, must be " #__dtype)
#define TORCH_CHECK_SHAPES(__x, __dim_x, __y, __dim_y, __scale_y) TORCH_CHECK((__x).size(__dim_x) == (__y).size(__dim_y) * __scale_y, #__x " and " #__y " have incompatible shapes")
#define TORCH_CHECK_SHAPES_OPT(__x, __dim_x, __y, __dim_y, __scale_y) TORCH_CHECK((__x).device().is_meta() || (__x).size(__dim_x) == (__y).size(__dim_y) * __scale_y, #__x " and " #__y " have incompatible shapes")
// Packing functions
void pack_rows_4
(
torch::Tensor input,
torch::Tensor output
)
{
const at::cuda::OptionalCUDAGuard device_guard(device_of(input));
TORCH_CHECK_DTYPE(input, kShort);
TORCH_CHECK_DTYPE(output, kInt);
TORCH_CHECK_SHAPES(input, 0, output, 0, 1);
TORCH_CHECK_SHAPES(input, 1, output, 1, 8);
int rows = input.size(0);
int columns = input.size(1);
pack_rows_4_cuda
(
(uint16_t*) input.data_ptr(),
(uint32_t*) output.data_ptr(),
rows,
columns
);
}
void pack_columns
(
torch::Tensor input,
torch::Tensor output,
int bits
)
{
const at::cuda::OptionalCUDAGuard device_guard(device_of(input));
TORCH_CHECK_DTYPE(input, kShort);
TORCH_CHECK_DTYPE(output, kInt);
TORCH_CHECK_SHAPES(input, 1, output, 1, 1);
int in_rows = input.size(0);
int columns = input.size(1);
int out_rows = output.size(0);
int exp_out_rows = in_rows * bits / 32;
TORCH_CHECK(out_rows == exp_out_rows, "Wrong output shape for input and bitrate")
pack_columns_cuda
(
(uint16_t*) input.data_ptr(),
(uint32_t*) output.data_ptr(),
in_rows,
out_rows,
columns,
bits
);
}
#include "quantize_func.h"
#include "../cuda/quantize.cuh"
void quantize_range
(
torch::Tensor quant,
torch::Tensor scale,
torch::Tensor out_q,
float qzero,
float maxq,
torch::Tensor hessian_inv,
torch::Tensor weights,
torch::Tensor error,
int a,
int b
)
{
int columns = weights.size(1);
int hcolumns = hessian_inv.size(1);
for (int c = a; c < b; c++)
{
quantize_cuda
(
((const float*) weights.data_ptr()) + c * columns,
((float*) quant.data_ptr()) + c * columns,
(const float*) scale.data_ptr(),
out_q.device().is_meta() ? NULL : ((uint16_t*) out_q.data_ptr()) + c * columns,
1,
columns,
qzero,
maxq
);
adjust_error_row_cuda
(
(const float*) hessian_inv.data_ptr(),
(float*) error.data_ptr(),
(const float*) weights.data_ptr(),
(const float*) quant.data_ptr(),
c,
columns,
hcolumns
);
vv_mul_sub_cuda
(
((const float*) hessian_inv.data_ptr()) + c * hcolumns + c,
((const float*) error.data_ptr()) + c * columns,
((float*) weights.data_ptr()) + c * columns,
b - c,
columns
);
}
torch::Tensor x = hessian_inv.slice(0, a, b).slice(1, b).transpose(0, 1);
torch::Tensor y = error.slice(0, a, b);
weights.slice(0, b).addmm_(x, y, 1.0f, -1.0f);
}
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
__forceinline__ __device__ half dot22_8_h(half2(&dq)[4], const half* a_ptr, const half g_result, const half qs_h)
{
half2 result = {};
const half2* a2_ptr = (const half2*)a_ptr;
#pragma unroll
for (int i = 0; i < 4; i++) result = __hfma2(dq[i], *a2_ptr++, result);
half result_h = __hadd(__low2half(result), __high2half(result));
return __hfma(result_h, qs_h, g_result);
}
__forceinline__ __device__ half dot22_16_h(half2(&dq)[8], const half* a_ptr, const half g_result, const half qs_h)
{
half2 result = {};
const half2* a2_ptr = (const half2*)a_ptr;
#pragma unroll
for (int i = 0; i < 8; i++) result = __hfma2(dq[i], *a2_ptr++, result);
half result_h = __hadd(__low2half(result), __high2half(result));
return __hfma(result_h, qs_h, g_result);
}
__forceinline__ __device__ half dot22_32_h(half2(&dq)[16], const half* a_ptr, const half g_result, const half qs_h)
{
half2 result = {};
const half2* a2_ptr = (const half2*)a_ptr;
#pragma unroll
for (int i = 0; i < 16; i += 1) result = __hfma2(dq[i], *a2_ptr++, result);
half result_h = __hadd(__low2half(result), __high2half(result));
return __hfma(result_h, qs_h, g_result);
}
name: Build Wheels
on: workflow_dispatch
jobs:
build_wheels:
name: ${{ matrix.os }} Python ${{ matrix.pyver }} CUDA ${{ matrix.cuda }}
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-20.04, windows-latest]
pyver: ["3.8", "3.9", "3.10", "3.11"]
cuda: ["11.7.0", "11.8.0", "12.1.1"]
defaults:
run:
shell: pwsh
env:
CUDAVER: ${{ matrix.cuda }}
PYVER: ${{ matrix.pyver }}
steps:
- name: Free Disk Space
uses: jlumbroso/[email protected]
if: runner.os == 'Linux'
with:
tool-cache: false
android: true
dotnet: true
haskell: true
large-packages: false
swap-storage: false
- uses: actions/checkout@v3
- uses: actions/setup-python@v3
with:
python-version: ${{ matrix.pyver }}
- name: Setup Mamba
uses: conda-incubator/[email protected]
with:
activate-environment: "build"
python-version: ${{ matrix.pyver }}
miniforge-variant: Mambaforge
miniforge-version: latest
use-mamba: true
add-pip-as-python-dependency: true
auto-activate-base: false
- name: Install Dependencies
run: |
$cudaVersion = $env:CUDAVER
$cudaVersionPytorch = $env:CUDAVER.Remove($env:CUDAVER.LastIndexOf('.')).Replace('.','')
$cudaChannels = ''
$cudaNum = [int]$cudaVersion.substring($cudaVersion.LastIndexOf('.')+1)
while ($cudaNum -ge 0) { $cudaChannels += '-c nvidia/label/cuda-' + $cudaVersion.Remove($cudaVersion.LastIndexOf('.')+1) + $cudaNum + ' '; $cudaNum-- }
mamba install -y 'cuda' $cudaChannels.TrimEnd().Split()
if (!(mamba list cuda)[-1].contains('cuda')) {sleep -s 10; mamba install -y 'cuda' $cudaChannels.TrimEnd().Split()}
if (!(mamba list cuda)[-1].contains('cuda')) {throw 'CUDA Toolkit failed to install!'}
if ([version]$env:CUDAVER -lt [version]'11.8.0') {$torchver = "torch==2.0.1"} else {$torchver = "torch==2.1.0"}
python -m pip install $torchver --index-url https://download.pytorch.org/whl/cu$cudaVersionPytorch
python -m pip install build wheel safetensors sentencepiece ninja
- name: Build Wheel
run: |
$env:CUDA_PATH = $env:CONDA_PREFIX
$env:CUDA_HOME = $env:CONDA_PREFIX
$cudaVersion = $env:CUDAVER
$cudaVersionPytorch = $env:CUDAVER.Remove($env:CUDAVER.LastIndexOf('.')).Replace('.','')
$BUILDTAG = "+cu$cudaVersionPytorch"
if ($IsLinux) {$env:LD_LIBRARY_PATH = $env:CONDA_PREFIX + '/lib:' + $env:LD_LIBRARY_PATH}
$env:TORCH_CUDA_ARCH_LIST = if ([version]$env:CUDAVER -lt [version]'11.8') {'6.0 6.1 7.0 7.5 8.0 8.6+PTX'} else {'6.0 6.1 7.0 7.5 8.0 8.6 8.9 9.0+PTX'}
python -m build -n --wheel -C--build-option=egg_info "-C--build-option=--tag-build=$BUILDTAG"
if ($IsLinux -and $env:PYVER -eq '3.11' -and $env:CUDAVER -eq '11.8.0') {$env:EXLLAMA_NOCOMPILE=1; python -m build -n}
- uses: actions/upload-artifact@v3
with:
name: 'wheels'
path: ./dist/*
build_rocm:
name: Build ROCm Wheels & Release
needs: build_wheels
uses: ./.github/workflows/build-wheels-rocm.yml
Metadata-Version: 2.1
Name: exllamav2
Version: 0.0.10
Home-page: https://github.com/turboderp/exllamav2
Author: turboderp
License: MIT
License-File: LICENSE
Requires-Dist: pandas
Requires-Dist: ninja
Requires-Dist: fastparquet
Requires-Dist: torch>=2.0.1
Requires-Dist: safetensors>=0.3.2
Requires-Dist: sentencepiece>=0.1.97
Requires-Dist: pygments
Requires-Dist: websockets
Requires-Dist: regex
# ExLlamaV2
ExLlamaV2 is an inference library for running local LLMs on modern consumer GPUs.
## Overview of differences compared to V1
- Faster, better kernels
- Cleaner and more versatile codebase
- Support for a new quant format (see below)
## Performance
Some quick tests to compare performance with V1. There may be more performance optimizations in the future, and
speeds will vary across GPUs, with slow CPUs still being a potential bottleneck:
| Model | Mode | Size | grpsz | act | V1: 3090Ti | V1: 4090 | V2: 3090Ti | V2: 4090 |
|------------|--------------|-------|-------|-----|------------|----------|------------|-------------|
| Llama | GPTQ | 7B | 128 | no | 143 t/s | 173 t/s | 175 t/s | **195** t/s |
| Llama | GPTQ | 13B | 128 | no | 84 t/s | 102 t/s | 105 t/s | **110** t/s |
| Llama | GPTQ | 33B | 128 | yes | 37 t/s | 45 t/s | 45 t/s | **48** t/s |
| OpenLlama | GPTQ | 3B | 128 | yes | 194 t/s | 226 t/s | 295 t/s | **321** t/s |
| CodeLlama | EXL2 4.0 bpw | 34B | - | - | - | - | 42 t/s | **48** t/s |
| Llama2 | EXL2 3.0 bpw | 7B | - | - | - | - | 195 t/s | **224** t/s |
| Llama2 | EXL2 4.0 bpw | 7B | - | - | - | - | 164 t/s | **197** t/s |
| Llama2 | EXL2 5.0 bpw | 7B | - | - | - | - | 144 t/s | **160** t/s |
| Llama2 | EXL2 2.5 bpw | 70B | - | - | - | - | 30 t/s | **35** t/s |
| TinyLlama | EXL2 3.0 bpw | 1.1B | - | - | - | - | 536 t/s | **635** t/s |
| TinyLlama | EXL2 4.0 bpw | 1.1B | - | - | - | - | 509 t/s | **590** t/s |
## How to
Clone the repository and install dependencies:
```
git clone https://github.com/turboderp/exllamav2
cd exllamav2
pip install -r requirements.txt
python test_inference.py -m <path_to_model> -p "Once upon a time,"
```
A simple console chatbot is included. Run it with:
```
python examples/chat.py -m <path_to_model> -mode llama
```
The `-mode` argument chooses the prompt format to use. `llama` is for the Llama(2)-chat finetunes, while `codellama`
probably works better for CodeLlama-instruct. `raw` will produce a simple chatlog-style chat that works with base
models and various other finetunes. You can also provide a custom system prompt with `-sp`.
## Integration and APIs
- [TabbyAPI](https://github.com/theroyallab/tabbyAPI/) is a FastAPI-based server that provides an OpenAI-style web API
compatible with [SillyTavern](https://sillytavernai.com/) and other frontends.
- [ExUI](https://github.com/turboderp/exui) is a simple, standalone single-user web UI that serves an ExLlamaV2 instance
directly with chat and notebook modes.
- [text-generation-webui](https://github.com/oobabooga/text-generation-webui) supports ExLlamaV2 through the **exllamav2**
and **exllamav2_HF** loaders.
## Installation
### Method 1: Install from source
To install the current dev version, clone the repo and run the setup script:
```
git clone https://github.com/turboderp/exllamav2
cd exllamav2
python setup.py install --user
```
By default this will also compile and install the Torch C++ extension (`exllamav2_ext`) that the library relies on.
You can skip this step by setting the `EXLLAMA_NOCOMPILE` environment variable:
```
EXLLAMA_NOCOMPILE= python setup.py install --user
```
This will install the "JIT version" of the package, i.e. it will install the Python components without building the
C++ extension in the process. Instead, the extension will be built the first time the library is used, then cached in
`~/.cache/torch_extensions` for subsequent use.
### Method 2: Install from release (with prebuilt extension)
Releases are available [here](https://github.com/turboderp/exllamav2/releases), with prebuilt wheels that contain the
extension binaries. Make sure to grab the right version, matching your platform, Python version (`cp`) and CUDA version.
Download an appropriate wheel, then run:
```
pip install exllamav2-0.0.4+cu118-cp310-cp310-linux_x86_64.whl
```
The `py3-none-any.whl` version is the JIT version which will build the extension on first launch. The `.tar.gz` file
can also be installed this way, and it will build the extension while installing.
### Method 3: Install from PyPI
A PyPI package is available as well. It can be installed with:
```
pip install exllamav2
```
The version available through PyPI is the JIT version (see above). Still working on a solution for distributing
prebuilt wheels via PyPI.
## EXL2 quantization
ExLlamaV2 supports the same 4-bit GPTQ models as V1, but also a new "EXL2" format. EXL2 is based on the same
optimization method as GPTQ and supports 2, 3, 4, 5, 6 and 8-bit quantization. The format allows for mixing quantization
levels within a model to achieve any average bitrate between 2 and 8 bits per weight.
Moreover, it's possible to apply multiple quantization levels to each linear layer, producing something akin to sparse
quantization wherein more important weights (columns) are quantized with more bits. The same remapping trick that lets
ExLlama work efficiently with act-order models allows this mixing of formats to happen with little to no impact on
performance.
Parameter selection is done automatically by quantizing each matrix multiple times, measuring the quantization
error (with respect to the chosen calibration data) for each of a number of possible settings, per layer. Finally, a
combination is chosen that minimizes the maximum quantization error over the entire model while meeting a target
average bitrate.
In my tests, this scheme allows Llama2 70B to run on a single 24 GB GPU with a 2048-token context, producing coherent
and mostly stable output with 2.55 bits per weight. 13B models run at 2.65 bits within 8 GB of VRAM, although currently
none of them uses GQA which effectively limits the context size to 2048. In either case it's unlikely that the model
will fit alongside a desktop environment. For now.
[![chat_screenshot](doc/llama2_70b_chat_thumb.png)](doc/llama2_70b_chat.png)
[![chat_screenshot](doc/codellama_13b_instruct_thumb.png)](doc/codellama_13b_instruct.png)
### Conversion
A script is provided to quantize models. Converting large models can be somewhat slow, so be warned. The conversion
script and its options are explained in [detail here](doc/convert.md)
### HuggingFace repos
- I've uploaded a few EXL2-quantized models to Hugging Face to play around with, [here](https://huggingface.co/turboderp).
- [LoneStriker](https://huggingface.co/LoneStriker) provides a large number of EXL2 models on Hugging Face.
// The macro below is used to shift rows of the A matrix and columns of the B matrix
// in shared memory to minimize possible bank conflicts.
// Before performing the nvcuda::wmma::mma_sync operation, the warp must load the matrix
// data using the nvcuda::wmma::load_matrix_sync operation. Although the memory access pattern
// is not specified for that function, each lane in the warp can read one or multiple matrix
// elements from different matrix rows or columns.
// For shared memory, such access can result in bank conflicts if different rows / columns
// of the matrix map to the same bank. By shifting each row and column by a few bytes, we
// make sure that they map to different banks, thus reducing the number of possible bank
// conflicts.
// The number of 16 two-byte "__nv_bfloat16" elements is chosen as the minimum possible shift because
// we must keep each row and column 256-bit aligned, as required by nvcuda::wmma::load_matrix_sync.
// #define SKEW_BF16 16
//
#define checkKernelErrors(expr) do { \
expr; \
\
cudaError_t __err = cudaGetLastError(); \
if (__err != cudaSuccess) { \
printf("Line %d: '%s' failed: %s\n", __LINE__, # expr, cudaGetErrorString(__err)); \
abort(); \
} \
} while(0)
DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
PLEASE DO ,1 SUB #7 <- #48
DO ,1 SUB #8 <- #26
DO ,1 SUB #9 <- #244
PLEASE DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP
DO .9 <- #16
DO .10 <- #0
DO .11 <- #1
(1) PLEASE READ OUT .11
DO .1 <- .10
DO .2 <- .11
PLEASE (1009) NEXT
DO .10 <- .11
DO .11 <- .3
DO (3) NEXT
DO (1) NEXT
(3) DO (4) NEXT
PLEASE GIVE UP
(4) DO .1 <- .9
DO .2 <- #1
PLEASE (1010) NEXT
DO .9 <- .3
DO .1 <- '.9~.9'~#1
PLEASE (1020) NEXT
DO RESUME .1
__global__ void testPtx(int *devBuff,float *devDummy,unsigned int *timeBuff){
unsigned int temp=0;
unsigned int start,end;
volatile unsigned int *tempPtr;
tempPtr = (volatile unsigned int *)&devBuff[0];
start = clock64();
temp=*tempPtr;
__threadfence();
end = clock64();
*devDummy=(float)(1.0/(float)(temp));
*timeBuff = (unsigned int)(end-start);
}
<% Option Explicit %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>VBScript Example</title>
</head>
<body>
<div><%
' Grab current time from Now() function.
' An '=' sign occurring after a context switch (<%) is shorthand
' for a call to the Write() method of the Response object.
Dim timeValue : timeValue = Now %>
The time, in 24-hour format, is
<%=Hour(timeValue)%>:<%=Minute(timeValue)%>:<%=Second(timeValue)%>.
</div>
</body>
</html>
using System;
namespace interptest
{
class MainClass
{
static UInt16[] pwmTable =
{
0,
1,
15,
53,
127,
249,
431,
685,
1023,
1457,
1999,
2661,
3455,
4393,
5487,
6749,
8191,
9825,
11663,
13717,
15999,
18521,
21295,
24333,
27647,
31249,
35151,
39365,
43903,
48777,
53999,
59581,
65535
};
static UInt16 intToPWM(UInt16 intensity)
{
UInt32 index = ((UInt32)intensity) >> 11;
UInt32 low = ((UInt32)pwmTable[index]);
UInt32 high = ((UInt32)pwmTable[index + 1]);
UInt32 highp = ((UInt32)intensity & 0x7ff) + 1;
UInt32 lowp = 0x800 - highp;
UInt32 mid = (lowp * low + highp * high) >> 11;
return (UInt16)mid;
}
public static void Main(string[] args)
{
for (UInt32 i = 0; i < 65536; i++)
{
UInt16 t = intToPWM((UInt16)i);
Console.WriteLine(t);
}
}
}
}
// Suppress all warnings from casts which overflow.
#![allow(overflowing_literals)]
fn main() {
let decimal = 65.4321_f32;
// Error! No implicit conversion
let integer: u8 = decimal;
// FIXME ^ Comment out this line
// Explicit conversion
let integer = decimal as u8;
let character = integer as char;
// Error! There are limitations in conversion rules.
// A float cannot be directly converted to a char.
let character = decimal as char;
// FIXME ^ Comment out this line
println!("Casting: {} -> {} -> {}", decimal, integer, character);
// when casting any value to an unsigned type, T,
// T::MAX + 1 is added or subtracted until the value
// fits into the new type
// 1000 already fits in a u16
println!("1000 as a u16 is: {}", 1000 as u16);
// 1000 - 256 - 256 - 256 = 232
// Under the hood, the first 8 least significant bits (LSB) are kept,
// while the rest towards the most significant bit (MSB) get truncated.
println!("1000 as a u8 is : {}", 1000 as u8);
// -1 + 256 = 255
println!(" -1 as a u8 is : {}", (-1i8) as u8);
// For positive numbers, this is the same as the modulus
println!("1000 mod 256 is : {}", 1000 % 256);
// When casting to a signed type, the (bitwise) result is the same as
// first casting to the corresponding unsigned type. If the most significant
// bit of that value is 1, then the value is negative.
// Unless it already fits, of course.
println!(" 128 as a i16 is: {}", 128 as i16);
// In boundary case 128 value in 8-bit two's complement representation is -128
println!(" 128 as a i8 is : {}", 128 as i8);
// repeating the example above
// 1000 as u8 -> 232
println!("1000 as a u8 is : {}", 1000 as u8);
// and the value of 232 in 8-bit two's complement representation is -24
println!(" 232 as a i8 is : {}", 232 as i8);
// Since Rust 1.45, the `as` keyword performs a *saturating cast*
// when casting from float to int. If the floating point value exceeds
// the upper bound or is less than the lower bound, the returned value
// will be equal to the bound crossed.
// 300.0 as u8 is 255
println!(" 300.0 as u8 is : {}", 300.0_f32 as u8);
// -100.0 as u8 is 0
println!("-100.0 as u8 is : {}", -100.0_f32 as u8);
// nan as u8 is 0
println!(" nan as u8 is : {}", f32::NAN as u8);
// This behavior incurs a small runtime cost and can be avoided
// with unsafe methods, however the results might overflow and
// return **unsound values**. Use these methods wisely:
unsafe {
// 300.0 as u8 is 44
println!(" 300.0 as u8 is : {}", 300.0_f32.to_int_unchecked::<u8>());
// -100.0 as u8 is 156
println!("-100.0 as u8 is : {}", (-100.0_f32).to_int_unchecked::<u8>());
// nan as u8 is 0
println!(" nan as u8 is : {}", f32::NAN.to_int_unchecked::<u8>());
}
}
// This function only gets compiled if the target OS is linux
#[cfg(target_os = "linux")]
fn are_you_on_linux() {
println!("You are running linux!");
}
// And this function only gets compiled if the target OS is *not* linux
#[cfg(not(target_os = "linux"))]
fn are_you_on_linux() {
println!("You are *not* running linux!");
}
fn main() {
are_you_on_linux();
println!("Are you sure?");
if cfg!(target_os = "linux") {
println!("Yes. It's definitely linux!");
} else {
println!("Yes. It's definitely *not* linux!");
}
}
struct Droppable {
name: &'static str,
}
// This trivial implementation of `drop` adds a print to console.
impl Drop for Droppable {
fn drop(&mut self) {
println!("> Dropping {}", self.name);
}
}
fn main() {
let _a = Droppable { name: "a" };
// block A
{
let _b = Droppable { name: "b" };
// block B
{
let _c = Droppable { name: "c" };
let _d = Droppable { name: "d" };
println!("Exiting block B");
}
println!("Just exited block B");
println!("Exiting block A");
}
println!("Just exited block A");
// Variable can be manually dropped using the `drop` function
drop(_a);
// TODO ^ Try commenting this line
println!("end of the main function");
// `_a` *won't* be `drop`ed again here, because it already has been
// (manually) `drop`ed
}
#include "Comms.h"
Subdevice::Subdevice(const uint8_t _address, Device& _device) :
address(_address),
next(NULL),
device(_device)
{
device.AddSubdevice(this);
}
MainSubdevice::MainSubdevice(const uint8_t _address, Device& _device) :
Subdevice(_address, _device)
{}
void MainSubdevice::command(const uint32_t cmd)
{
switch (cmd)
{
case MAINSUBDEVICE_CMD_PING: cmd_ping(); break;
case MAINSUBDEVICE_CMD_LIST_SUBDEVICES: cmd_list_subdevices(); break;
default:
device.send32(ERROR_BAD_COMMAND);
break;
}
}
void MainSubdevice::cmd_ping()
{
device.send32(ACK);
}
void MainSubdevice::cmd_list_subdevices()
{
int size = 9;
uint32_t* p = (uint32_t*) (device.txBuffer + 4);
*p++ = id();
Subdevice* subdevice = this;
while (subdevice = subdevice->next)
{
*p++ = subdevice->id();
size += 4;
}
device.finishPacket(size);
}
Device::Device(const uint8_t _address) :
address(_address),
subdevices(NULL),
mainSubdevice(MainSubdevice(0, *this))
{
Serial.begin(115200);
rxHead = 0;
rxTail = 0;
lastRX = millis();
}
void Device::pump()
{
readSerial();
int rec = rxTail - rxHead;
if (rec < 0) rec += RX_BUFFER_SIZE;
if (rec >= 2)
{
uint8_t a = rxBuffer[rxHead];
uint8_t b = rxBuffer[(rxHead + 1) & RX_BUFFER_MASK];
int exp = (b << 8) | a;
if (exp == rec)
{
if (exp < 9)
{
// malformed packet
Serial.println("malform"); // TODO
rxHead = (rxHead + exp) & RX_BUFFER_MASK;
}
else if (!checkChecksum())
{
// failed checksum
Serial.println("badchecsum"); // TODO
rxHead = (rxHead + exp) & RX_BUFFER_MASK;
}
else
{
uint16_t size = consume16();
uint8_t deviceAddress = consume8();
if (deviceAddress != address)
{
rxHead = (rxHead + size - 3) & RX_BUFFER_MASK;
}
else
{
uint8_t subdeviceAddress = consume8();
uint32_t command = consume32();
int endOfPacket = (rxHead + size - 8) & RX_BUFFER_MASK;
dispatch(subdeviceAddress, command);
rxHead = endOfPacket;
}
}
}
}
}
void Device::readSerial()
{
if (Serial.available())
{
uint8_t input = Serial.read();
rxBuffer[rxTail++] = input;
rxTail &= RX_BUFFER_MASK;
if (rxTail == rxHead)
{
// overflow
}
Serial.write(input);// TODO
lastRX = millis();
}
else if (rxTail != rxHead)
{
uint32_t timeSinceReceive = millis() - lastRX;
if (timeSinceReceive >= RX_TIMEOUT)
{
Serial.println("tieout"); // TODO
rxHead = rxTail;
}
}
}
void Device::dispatch(const uint8_t subdeviceAddress, const uint32_t cmd)
{
Subdevice* subdevice = subdevices;
while (subdevice != NULL)
{
if (subdevice->address == subdeviceAddress)
{
subdevice->command(cmd);
return;
}
subdevice = subdevice->next;
}
send32(ERROR_SUBDEVICE_NOT_FOUND);
}
uint8_t Device::consume8()
{
uint8_t a = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
return a;
}
uint16_t Device::consume16()
{
uint8_t a = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
uint8_t b = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
return (((uint16_t)b) << 8) | ((uint16_t) a);
}
uint32_t Device::consume32()
{
uint8_t a = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
uint8_t b = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
uint8_t c = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
uint8_t d = rxBuffer[rxHead++];
rxHead &= RX_BUFFER_MASK;
return (((uint32_t)d) << 24) | (((uint32_t)c) << 16) | (((uint32_t)b) << 8) | ((uint32_t)a);
}
void Device::send32(const uint32_t msg)
{
uint32_t* p = (uint32_t*) (txBuffer + 4);
*p = msg;
finishPacket(9);
}
static const uint8_t crc_table[] =
{
0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31,
0x24, 0x23, 0x2a, 0x2d, 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 0xe0, 0xe7, 0xee, 0xe9,
0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1,
0xb4, 0xb3, 0xba, 0xbd, 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 0xb7, 0xb0, 0xb9, 0xbe,
0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16,
0x03, 0x04, 0x0d, 0x0a, 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 0x89, 0x8e, 0x87, 0x80,
0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8,
0xdd, 0xda, 0xd3, 0xd4, 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 0x19, 0x1e, 0x17, 0x10,
0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f,
0x6a, 0x6d, 0x64, 0x63, 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 0xae, 0xa9, 0xa0, 0xa7,
0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef,
0xfa, 0xfd, 0xf4, 0xf3
};
bool Device::checkChecksum()
{
uint8_t crc = 0;
int c = rxHead;
int ce = rxTail - 1;
while (c != ce)
{
crc = crc_table[crc ^ rxBuffer[c++]];
c &= RX_BUFFER_MASK;
}
return crc == rxBuffer[c];
}
void Device::finishPacket(const int len)
{
txBuffer[0] = len & 0xff;
txBuffer[1] = len >> 8;
txBuffer[2] = 0;
txBuffer[3] = 0;
uint8_t crc = 0;
uint8_t* p = txBuffer;
uint8_t* pe = txBuffer + len - 1;
while(p < pe)
{
crc = crc_table[crc ^ *p++];
}
*p = crc;
Serial.write(txBuffer, len);
}
void Device::AddSubdevice(Subdevice* subdevice)
{
if (subdevices == NULL)
{
subdevices = subdevice;
}
else
{
Subdevice* dev = subdevices;
while (dev->next) dev = dev->next;
dev->next = subdevice;
}
}
# ExLlama
A standalone Python/C++/CUDA implementation of Llama for use with 4-bit GPTQ weights, designed to be fast and
memory-efficient on modern GPUs.
Disclaimer: The project is coming along, but it's still a work in progress!
## Hardware requirements
I am developing on an RTX 4090 and an RTX 3090-Ti. 30-series and later NVIDIA GPUs should be well supported, but
anything Pascal or older with poor FP16 support isn't going to perform well.
[AutoGPTQ](https://github.com/PanQiWei/AutoGPTQ) or [GPTQ-for-LLaMa](https://github.com/qwopqwop200/GPTQ-for-LLaMa)
are better options at the moment for older GPUs. ROCm is also theoretically supported (via HIP) though I currently
have no AMD devices to test or optimize on.
## Dependencies
* Python 3.9 or newer
* `torch` tested on 2.0.1 and 2.1.0 (nightly) with cu118
* `safetensors` 0.3.2
* `sentencepiece`
* `ninja`
Additionally, only for the web UI:
* `flask`
* `waitress`
## Linux/WSL prerequisites
pip install --pre torch --index-url https://download.pytorch.org/whl/nightly/cu118
## Windows prerequisites
To run on Windows (without WSL):
1. Install [MSVC 2022](https://visualstudio.microsoft.com/downloads/). You can choose to install the whole `Visual
Studio 2022` IDE, or alternatively just the `Build Tools for Visual Studio 2022` package (make sure `Desktop
development with C++` is ticked in the installer), it doesn't really matter which.
2. Install the appropriate version of [PyTorch](https://pytorch.org/get-started/locally/), choosing one of the CUDA
versions. I am developing on the nightly build, but the stable version (2.0.1) should also work.
3. Install CUDA Toolkit, ([11.7](https://developer.nvidia.com/cuda-11-7-0-download-archive) and
[11.8](https://developer.nvidia.com/cuda-11-8-0-download-archive) both seem to work, just make sure to match PyTorch's
Compute Platform version).
4. For best performance, enable Hardware Accelerated GPU Scheduling.
## How to
Clone repo, install dependencies, and run benchmark:
git clone https://github.com/turboderp/exllama
cd exllama
pip install -r requirements.txt
python test_benchmark_inference.py -d <path_to_model_files> -p -ppl
The CUDA extension is loaded at runtime so there's no need to install it separately. It will be compiled on the first
run and cached to `~/.cache/torch_extensions/` which could take a little while. If nothing happens at first, give it
a minute to compile.
Chatbot example:
python example_chatbot.py -d <path_to_model_files> -un "Jeff" -p prompt_chatbort.txt
## Python module
jllllll currently maintains an installable Python module [here](https://github.com/jllllll/exllama) which may be more
suitable for integrating ExLlama with other projects
## Web UI
I also made a simple web UI for it. Don't look at the JavaScript, it was mostly written by ChatGPT and it will haunt
your dreams. But it sort of works, and it's kinda fun, especially multibot mode:
![_screenshot.jpg](doc/_screenshot.jpg)
To run it:
pip install -r requirements-web.txt
python webui/app.py -d <path_to_model_files>
Note that sessions are stored in `~/exllama_sessions/` by default. You can change that location with `-sd` if you want.
## Docker
For security benefits and easier deployment, it is also possible to run the web UI in an isolated docker container. Note: the docker image currently only supports NVIDIA GPUs.
### Requirements
- [Docker](https://docs.docker.com/engine/install/)
- [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
It is recommended to run docker in [rootless mode](https://docs.docker.com/engine/security/rootless/).
### Build
The easiest way to build the docker image is using docker compose. First, set the `MODEL_PATH` and `SESSIONS_PATH` variables in the `.env` file to the actual directories on the host. Then run:
```
docker compose build
```
It is also possible to manually build the image:
```
docker build -t exllama-web .
```
NOTE: by default, the service inside the docker container is run by a non-root user. Hence, the ownership of bind-mounted directories (`/data/model` and `/data/exllama_sessions` in the default `docker-compose.yml` file) is changed to this non-root user in the container entrypoint (`entrypoint.sh`). To disable this, set `RUN_UID=0` in the `.env` file if using `docker compose`, or the following command if you manually build the image:
```
docker build -t exllama-web --build-arg RUN_UID=0 .
```
### Run
Using docker compose:
```
docker compose up
```
The web UI can now be accessed on the host at http://localhost:5000.
The configuration can be viewed in `docker-compose.yml` and changed by creating a `docker-compose.override.yml` file.
Run manually:
```
docker run --gpus all -p 5000:5000 -v <path_to_model_dir>:/data/model/ -v <path_to_session_dir>:/data/exllama_sessions --rm -it exllama-web --host 0.0.0.0:5000
```
## Results so far
### New implementation
| Model | Size | grpsz | act | Seq. len. | VRAM | Prompt | Best | Worst | Ppl |
|------------|-------|-------|-----|----------------------|-----------|------------|---------|---------|------|
| Llama | 7B | 128 | no | 2,048 t | 5,194 MB | 13,918 t/s | 173 t/s | 140 t/s | 6.45 |
| Llama | 13B | 128 | no | 2,048 t | 9,127 MB | 7,507 t/s | 102 t/s | 86 t/s | 5.60 |
| Llama | 33B | 128 | no | 2,048 t | 20,795 MB | 2,959 t/s | 47 t/s | 40 t/s | 4.60 |
| Llama | 33B | 128 | yes | 2,048 t | 20,795 MB | 2,784 t/s | 45 t/s | 37 t/s | 4.55 |
| Llama | 33B | 32 | yes | 1,550 t <sup>1</sup> | 21,486 MB | 2,636 t/s | 41 t/s | 37 t/s | 4.52 |
| Koala | 13B | 128 | yes | 2,048 t | 9,127 MB | 5,529 t/s | 93 t/s | 79 t/s | 6.73 |
| WizardLM | 33B | - | yes | 2,048 t | 20,199 MB | 2,313 t/s | 47 t/s | 40 t/s | 5.75 |
| OpenLlama | 3B | 128 | yes | 2,048 t | 3,128 MB | 16,419 t/s | 226 t/s | 170 t/s | 7.81 |
<sup>1</sup> Can not achieve full sequence length without OoM
All tests done on stock RTX 4090 / 12900K, running with a desktop environment, with a few other apps also using VRAM.
**"Prompt"** speed is inference over the sequence length listed minus 128 tokens. **"Worst"** is the average speed for
the last 128 tokens of the full context (worst case) and **"Best"** lists the speed for the first 128 tokens in an
empty sequence (best case.)
VRAM usage is as reported by PyTorch and does not include PyTorch's own overhead (CUDA kernels,
internal buffers etc.) This is somewhat unpredictable anyway. Best bet is to just optimize VRAM usage by the model,
probably aiming for 20 GB on a 24 GB GPU to ensure there is room for a desktop environment and all of Torch's
internals.
Perplexity is measured only to verify that the models are working. The dataset used is a particular, small sample from
WikiText, so scores are not comparable to other Llama benchmarks and only useful for comparing the different Llama
models to one another.
### Dual GPU results
The following benchmarks are from a 4090 + 3090-Ti with `-gs 17.2,24`:
| Model | Size | groupsize | act | Seq. len. | VRAM | Prompt | Best | Worst | Ppl |
|---------|------|-----------|-----|----------------|-----------|-----------|--------|---------|-------|
| Llama | 65B | 128 | yes | 2,048 t | 39,804 MB | 1,109 t/s | 20 t/s | 18 t/s | 4.20 |
| Llama | 65B | 32 | yes | 2,048 t | 43,424 MB | 1,037 t/s | 17 t/s | 16 t/s | 4.11 |
| Llama-2 | 70B | 128 | yes | 2,048 t | 40,680 MB | 914 t/s | 17 t/s | 14 t/s | 4.15 |
| Llama-2 | 70B | 32 | yes | 2,048 t | 36,815 MB | 874 t/s | 15 t/s | 12 t/s | 4.10 |
Note that perplexity scores may not be strictly apples-to-apples between Llama and Llama 2 due to their different
pretraining datasets.
## Todo
Moved the todo list [here](doc/TODO.md).
## Compatibility
[Here](doc/model_compatibility.md) is a list of models confirmed to be working right now.
import * as util from "./util.js";
import * as mainmenu from "./mainmenu.js";
import * as globals from "./globals.js";
import * as controls from "./controls.js";
import * as overlay from "./overlay.js";
export class NotepadSettings {
constructor(parent) {
this.element = util.newHFlex();
this.parent = parent;
this.settings = this.parent.notepadSettings;
//console.log(this.settings);
this.populate();
}
populate() {
this.element.innerHTML = "";
this.sss_genParams = new controls.CollapsibleSection(null, "Generation parameters");
this.sss_sampling = new controls.CollapsibleSection(null, "Sampling");
this.element.appendChild(this.sss_genParams.element);
this.element.appendChild(this.sss_sampling.element);
// Generation params
this.sss_i_maxTokens = new controls.SettingsSlider("sss-item-left", "Max tokens", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 16, 2048, null, this.settings, "maxtokens", () => { this.updateView(true); });
this.sss_i_chunkTokens = new controls.SettingsSlider("sss-item-left", "Chunk tokens", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 16, 2048, null, this.settings, "chunktokens", () => { this.updateView(true); });
this.sss_stopConditions = new controls.CollapsibleSection(null, "Stop conditions");
this.sss_genParams.inner.appendChild(this.sss_i_maxTokens.element);
this.sss_genParams.inner.appendChild(this.sss_i_chunkTokens.element);
this.element.appendChild(this.sss_stopConditions.element);
// Sampling
this.sss_i_temperature = new controls.SettingsSlider("sss-item-left", "Temperature", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 3, null, this.settings, "temperature", () => { this.updateView(true); });
this.sss_i_topK = new controls.SettingsSlider("sss-item-left", "Top K", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 0, 1000, { "0": "off" }, this.settings, "top_k", () => { this.updateView(true); });
this.sss_i_topP = new controls.SettingsSlider("sss-item-left", "Top P", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "top_p", () => { this.updateView(true); });
this.sss_i_minP = new controls.SettingsSlider("sss-item-left", "Min P", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "min_p", () => { this.updateView(true); });
this.sss_i_tfs = new controls.SettingsSlider("sss-item-left", "TFS", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "tfs", () => { this.updateView(true); });
this.sss_i_typical = new controls.SettingsSlider("sss-item-left", "Typical", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "typical", () => { this.updateView(true); });
this.sss_i_repPenalty = new controls.SettingsSlider("sss-item-left", "Rep. penalty", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 1, 3, { "1.00": "off" }, this.settings, "repp", () => { this.updateView(true); });
this.sss_i_repRange = new controls.SettingsSlider("sss-item-left", "Rep. range", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 0, 4096, { "0": "off" }, this.settings, "repr", () => { this.updateView(true); });
this.sss_i_mirostat = new controls.CheckboxLabel("sss-item-right clickable", "Mirostat", this.settings, "mirostat", () => { this.updateView(true); });
this.sss_i_mirostat_tau = new controls.SettingsSlider("sss-item-left", "Mirostat tau", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0.01, 10, null, this.settings, "mirostat_tau", () => { this.updateView(true); });
this.sss_i_mirostat_eta = new controls.SettingsSlider("sss-item-left", "Mirostat eta", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0.01, 5, null, this.settings, "mirostat_eta", () => { this.updateView(true); });
this.sss_sampling.inner.appendChild(this.sss_i_temperature.element);
this.sss_sampling.inner.appendChild(this.sss_i_topK.element);
this.sss_sampling.inner.appendChild(this.sss_i_topP.element);
this.sss_sampling.inner.appendChild(this.sss_i_minP.element);
this.sss_sampling.inner.appendChild(this.sss_i_tfs.element);
this.sss_sampling.inner.appendChild(this.sss_i_typical.element);
this.sss_sampling.inner.appendChild(this.sss_i_repPenalty.element);
this.sss_sampling.inner.appendChild(this.sss_i_repRange.element);
this.sss_sampling.inner.appendChild(this.sss_i_mirostat.element);
this.sss_sampling.inner.appendChild(this.sss_i_mirostat_tau.element);
this.sss_sampling.inner.appendChild(this.sss_i_mirostat_eta.element);
// Stop conditions
this.populate_stop_conditions();
this.updateView();
}
populate_stop_conditions() {
this.sss_stopConditions.inner.innerHTML = "";
this.sss_i_stopconditions = [];
for (let i = 0; i < this.settings.stop_conditions.length; i++) {
this.sss_i_stopconditions[i] = new controls.CheckboxTextboxButton(
"stop_condition_" + i,
"sss-item-left",
"Incl.",
"sss-item-mid sss-item-textbox",
"",
this.settings,
"stop_conditions",
i,
"text",
"inclusive",
(v) => { return v != ""; },
() => { this.updateView(true); },
"✕ Remove",
() => {
this.settings.stop_conditions.splice(i, 1);
this.populate_stop_conditions();
this.updateView(true);
}
);
}
for (let i = 0; i < this.settings.stop_conditions.length; i++)
this.sss_stopConditions.inner.appendChild(this.sss_i_stopconditions[i].element);
if (this.settings.stop_conditions.length < 10) {
this.sss_i_addStopCondition = new controls.LinkButton("+ Add...", null, () => {
this.settings.stop_conditions.push({text: "", inclusive: false});
this.populate_stop_conditions();
this.updateView(true);
}, "sss-item-link");
this.sss_stopConditions.inner.appendChild(this.sss_i_addStopCondition.element);
}
}
updateView(send = false) {
// Settings visibility
let mirostat = this.settings.mirostat;
this.sss_i_mirostat_tau.setVisible(mirostat);
this.sss_i_mirostat_eta.setVisible(mirostat);
// Send
if (send) this.send();
//console.log(this.settings);
}
send(post = null) {
//console.log(this.settings);
let packet = {};
packet.settings = this.settings;
if (!this.parent.notepadID || this.parent.notepadID == "new") {
fetch("/api/new_notepad", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(packet) })
.then(response => response.json())
.then(response => {
this.parent.parent.lastNotepadUUID = response.notepad.notepad_uuid;
this.parent.parent.onEnter();
if (post) post(response);
});
} else {
fetch("/api/update_notepad_settings", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(packet) })
.then(response => response.json())
.then(response => {
if (post) post(response);
});
}
}
}
input[type=range] {
-webkit-appearance: none;
margin: 4px 0;
width: 100%;
background: transparent;
}
input[type=range]:focus {
outline: none;
}
input[type=range]::-webkit-slider-runnable-track {
width: 100%;
height: 6.4px;
cursor: pointer;
box-shadow: 1px 1px 1px #00000020, 0px 0px 1px #0d0d0d40;
background: var(--slider-track-color);
border-radius: 1.0px;
border: 0.2px solid #01010120;
}
input[type=range]::-webkit-slider-thumb {
box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
border: 1px solid #00000080;
height: 16px;
width: 16px;
border-radius: 3px;
background: var(--slider-thumb-color);
cursor: pointer;
-webkit-appearance: none;
margin-top: -5px;
}
input[type=range]:hover::-webkit-slider-runnable-track {
/* background: var(--slider-hover-color);*/
}
input[type=range]::-moz-range-track {
width: 100%;
height: 4.4px;
cursor: pointer;
box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
background: var(--slider-track-color);
border-radius: 1.3px;
border: 0.2px solid var(--slider-track-color);;
}
input[type=range]::-moz-range-thumb {
box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
border: 1px solid #00000080;
height: 13px;
width: 13px;
border-radius: 3px;
background: var(--slider-thumb-color);
cursor: pointer;
}
input[type=range]:hover::-moz-range-track {
/* background: var(--slider-hover-color);*/
}
import * as util from "./util.js";
class PageOverlay {
constructor() {
this.keyboardDisabled = false;
document.addEventListener("keydown", (e) => {
if (this.keyboardDisabled) e.preventDefault();
});
this.overlayElement = util.newDiv(null, "page-overlay");
document.body.appendChild(this.overlayElement);
this.items = new Map();
}
add(mode, control) {
this.items.set(mode, control);
this.overlayElement.appendChild(control.element);
return control;
}
setMode(mode = null) {
if (!mode) {
this.keyboardDisabled = false;
this.overlayElement.style.display = "none";
this.items.forEach((v, k) => { v.setVisible(false); });
} else {
this.keyboardDisabled = true;
this.overlayElement.style.display = "flex";
this.items.forEach((v, k) => { v.setVisible(mode === k); });
}
}
}
class Overlay {
constructor() {
this.element = util.newDiv(null, "overlay");
}
setVisible(visible) {
this.element.style.display = visible ? "flex" : "none";
}
}
class BusyOverlay extends Overlay {
constructor() {
super();
this.element.innerHTML = "<p class='p-header'>Please wait</p>" +
"<div class='spinner'><div></div><div></div><div></div><div></div></div>";
}
}
class LoadingOverlay extends Overlay {
constructor() {
super();
this.element.innerHTML = "<p class='p-header'>Loading</p>";
this.box = util.newDiv(null, "progressbar-box");
this.element.appendChild(this.box);
this.bar = util.newDiv(null, "progressbar-bar");
this.box.appendChild(this.bar);
}
setProgress(a, b) {
let percentage = 100 * (a / b);
this.bar.style.width = percentage + '%';
}
}
export var pageOverlay = new PageOverlay();
export var busyOverlay = pageOverlay.add("busy", new BusyOverlay());
export var loadingOverlay = pageOverlay.add("loading", new LoadingOverlay());
@app.route("/api/load_model", methods=['POST'])
def api_load_model():
global api_lock, verbose
if verbose: print("/api/load_model")
with api_lock:
data = request.get_json()
if verbose: print("<-", data)
if verbose: print("-> ...")
result = Response(stream_with_context(load_model(data)), mimetype = 'application/json')
if verbose: print("->", result)
return result
@app.route("/api/unload_model")
def api_unload_model():
global api_lock, verbose
if verbose: print("/api/unload_model")
with api_lock:
result = unload_model()
if verbose: print("->", result)
return json.dumps(result) + "\n"
@app.route("/api/list_sessions")
def api_list_sessions():
global api_lock, verbose
if verbose: print("/api/list_sessions")
with api_lock:
s, c = list_sessions()
result = { "result": "ok", "sessions": s, "current_session": c }
if verbose: print("-> (...)")
return json.dumps(result) + "\n"
@app.route("/api/get_default_settings")
def api_get_default_settings():
global api_lock, verbose
if verbose: print("/api/get_default_settings")
with api_lock:
result = { "result": "ok",
"session_settings": get_default_session_settings(),
"notepad_settings": get_default_notepad_settings(),
"prompt_formats": list_prompt_formats() }
return json.dumps(result) + "\n"
@app.route("/api/set_session", methods=['POST'])
def api_set_session():
global api_lock, verbose
if verbose: print("/api/set_session")
with api_lock:
data = request.get_json()
if verbose: print("<-", data)
session = set_session(data)
if session is not None:
result = { "result": "ok",
"session": session,
"prompt_formats": list_prompt_formats() }
if verbose: print("-> (...)")
else:
result = { "result": "fail" }
if verbose: print("->", result)
return json.dumps(result) + "\n"
@app.route("/api/new_session", methods=['POST'])
def api_new_session():
global api_lock, verbose
if verbose: print("/api/new_session")
with api_lock:
data = request.get_json()
if verbose: print("<-", data)
session = new_session()
if "settings" in data: get_session().update_settings(data["settings"])
if "user_input_text" in data: get_session().user_input(data)
if "new_name" in data: get_session().rename(data)
result = { "result": "ok", "session": session }
if verbose: print("-> (...)")
return json.dumps(result) + "\n"
@app.route("/api/rename_session", methods=['POST'])
def api_rename_session():
global api_lock, verbose
if verbose: print("/api/rename_session")
with api_lock:
data = request.get_json()
if verbose: print("<-", data)
s = get_session()
s.rename(data)
result = { "result": "ok" }
if verbose: print("->", result)
return json.dumps(result) + "\n"
def is_rocm_installed():
# Implement a check for ROCm (e.g., looking for specific files or running a command)
# Return True if ROCm is found, False otherwise
pass
def is_cuda_installed():
# Implement a check for CUDA
# Return True if CUDA is found, False otherwise
pass
def install_packages():
if is_rocm_installed():
subprocess.run([sys.executable, '-m', 'pip', 'install', 'some_rocm_package'])
elif is_cuda_installed():
subprocess.run([sys.executable, '-m', 'pip', 'install', 'some_cuda_package'])
else:
print("Neither ROCm nor CUDA detected.")
if __name__ == "__main__":
install_packages()
#ifndef _qdq_4_cuh
#define _qdq_4_cuh
#include "qdq_util.cuh"
#include "../../config.h"
#if QMODE_4BIT == 1
// Permutation:
//
// 77775555 33331111 66664444 22220000
__forceinline__ __device__ void shuffle_4bit_8
(
uint32_t* q,
int stride
)
{
uint32_t qa = q[0];
uint32_t qb = 0;
#pragma unroll
for (int i = 0; i < 4; i++)
{
uint32_t qa0 = qa & 0x0f;
uint32_t qa1 = (qa & 0xf0) >> 4;
qa >>= 8;
qb |= (qa1 << (i * 4 + 16));
qb |= (qa0 << (i * 4));
}
q[0] = qb;
}
__forceinline__ __device__ void dequant_4bit_8
(
const uint32_t q_0,
half2 (&dq)[4],
int stride
)
{
const uint32_t c0 = 0x64006400;
const half y16_ = __float2half_rn(1.0f / 16.0f);
const half2 y16 = __halves2half2(y16_, y16_);
const half z1_ = __float2half_rn(-1024.0f - 8.0f);
const half z16_ = __float2half_rn(-1024.0f / 16.0f - 8.0f);
const half2 z1 = __halves2half2(z1_, z1_);
const half2 z16 = __halves2half2(z16_, z16_);
uint32_t qa = q_0;
half2_uint32 q0((qa & 0x000f000f) | c0); // half2(q[ 0], q[ 1]) + 1024
half2_uint32 q1((qa & 0x00f000f0) | c0); // half2(q[ 2], q[ 3]) * 16 + 1024
qa >>= 8;
half2_uint32 q2((qa & 0x000f000f) | c0); // half2(q[ 4], q[ 5]) + 1024
half2_uint32 q3((qa & 0x00f000f0) | c0); // half2(q[ 6], q[ 7]) * 16 + 1024
dq[0] = __hadd2(q0.as_half2, z1);
dq[1] = __hfma2(q1.as_half2, y16, z16);
dq[2] = __hadd2(q2.as_half2, z1);
dq[3] = __hfma2(q3.as_half2, y16, z16);
}
__forceinline__ __device__ void dequant_4bit_8_prep_zero_scale
(
const uint32_t zero,
const half scale,
half2 (&z1z16)[2],
half2 (&y1y16)[2]
)
{
half_uint16 z1(0xe400 | zero); // half(-1024.0f - zero);
half z16 = __hsub(__int2half_rn(-64), __int2half_rn(zero));
half2 scale2 = __half2half2(scale);
z1z16[0] = __hmul2(scale2, __half2half2(z1.as_half));
z1z16[1] = __hmul2(scale2, __half2half2(z16));
const half y1 = __float2half_rn(1.0f);
const half y16 = __float2half_rn(1.0f / 16.0f);
y1y16[0] = __hmul2(scale2, __half2half2(y1));
y1y16[1] = __hmul2(scale2, __half2half2(y16));
}
__forceinline__ __device__ void dequant_4bit_8_prep_zero
(
const uint32_t zero,
half2(&z1z16)[2],
half2(&y1y16)[2]
)
{
half_uint16 z1(0xe400 | zero); // half(-1024.0f - zero);
half z16 = __hsub(__int2half_rn(-64), __int2half_rn(zero));
z1z16[0] = __half2half2(z1.as_half);
z1z16[1] = __half2half2(z16);
const half y1 = __float2half_rn(1.0f);
const half y16 = __float2half_rn(1.0f / 16.0f);
y1y16[0] = __half2half2(y1);
y1y16[1] = __half2half2(y16);
}
__forceinline__ __device__ void dequant_4bit_8_gptq
(
const uint32_t q_0,
half2 (&dq)[4],
half2 (&z1z16)[2],
half2 (&y1y16)[2],
int stride,
bool scaled
)
{
const uint32_t c0 = 0x64006400;
uint32_t qa = q_0;
half2_uint32 q0((qa & 0x000f000f) | c0); // half2( q[0] + 1024, q[1] + 1024 )
half2_uint32 q1((qa & 0x00f000f0) | c0); // half2( q[2] * 16 + 1024, q[3] * 16 + 1024 )
qa >>= 8;
half2_uint32 q2((qa & 0x000f000f) | c0); // half2( q[4] + 1024, q[5] + 1024 )
half2_uint32 q3((qa & 0x00f000f0) | c0); // half2( q[6] * 16 + 1024, q[7] * 16 + 1024 )
if (scaled)
{
dq[0] = __hfma2(q0.as_half2, y1y16[0], z1z16[0]); // half2( q[0] * s - z * s, q[1] * s - z * s)
dq[1] = __hfma2(q1.as_half2, y1y16[1], z1z16[1]); // half2( q[2] * s - z * s, q[3] * s - z * s)
dq[2] = __hfma2(q2.as_half2, y1y16[0], z1z16[0]);
dq[3] = __hfma2(q3.as_half2, y1y16[1], z1z16[1]);
}
else
{
dq[0] = __hadd2(q0.as_half2, z1z16[0]); // half2( q[0] - z, q[1] - z )
dq[1] = __hfma2(q1.as_half2, y1y16[1], z1z16[1]); // half2( q[2] - z, q[3] - z )
dq[2] = __hadd2(q2.as_half2, z1z16[0]); // half2( q[4] - z, q[5] - z )
dq[3] = __hfma2(q3.as_half2, y1y16[1], z1z16[1]); // half2( q[6] - z, q[7] - z )
}
}
#else
__forceinline__ __device__ void shuffle_4bit_8
(
uint32_t* q,
int stride
)
{
}
__forceinline__ __device__ void dequant_4bit_8
(
const uint32_t q_0,
half2 (&dq)[4],
int stride
)
{
half dqh[8];
for (int i = 0; i < 8; i++) dqh[i] = dq_ns(exb(q_0, i * 4, 0x0f), 8);
for (int i = 0; i < 4; i++) dq[i] = __halves2half2(dqh[i * 2], dqh[i * 2 + 1]);
}
__forceinline__ __device__ void dequant_4bit_8_prep_zero_scale
(
const uint32_t zero,
const half scale,
half2 (&z1)[2],
half2 (&y1)[2]
)
{
half z = __int2half_rn(-((int)zero));
z = __hmul(z, scale);
z1[0] = __half2half2(z);
y1[0] = __half2half2(scale);
}
__forceinline__ __device__ void dequant_4bit_8_prep_zero
(
const uint32_t zero,
half2(&z1)[2],
half2(&y1)[2]
)
{
half z = __int2half_rn(-((int)zero));
z1[0] = __half2half2(z);
}
__forceinline__ __device__ void dequant_4bit_8_gptq
(
const uint32_t q_0,
half2 (&dq)[4],
half2 (&z1)[2],
half2 (&y1)[2],
int stride,
bool scaled
)
{
half2 dqh2[8];
uint32_t qa = q_0;
for (int i = 0; i < 4; i++)
{
half d0 = __int2half_rn(qa & 0x0f); qa >>= 4;
half d1 = __int2half_rn(qa & 0x0f); qa >>= 4;
dqh2[i] = __halves2half2(d0, d1);
}
if (scaled)
{
dq[0] = __hfma2(dqh2[0], y1[0], z1[0]);
dq[1] = __hfma2(dqh2[1], y1[0], z1[0]);
dq[2] = __hfma2(dqh2[2], y1[0], z1[0]);
dq[3] = __hfma2(dqh2[3], y1[0], z1[0]);
}
else
{
dq[0] = __hadd2(dqh2[0], z1[0]);
dq[1] = __hadd2(dqh2[1], z1[0]);
dq[2] = __hadd2(dqh2[2], z1[0]);
dq[3] = __hadd2(dqh2[3], z1[0]);
}
}
#endif
#endif
import gc
import torch
from torch import nn
import torch.nn.functional as F
import math
from exllamav2.ext import exllamav2_ext as ext_c, none_tensor
from exllamav2.util import list_live_tensors
class AdaptiveQuantizer:
norm: float = 3.5
max_p: float = 1.0
min_p: float = 0.75
p_grid: int = 48
bits: int
scale_bits: int
scale_range: float = 1.0
scale: torch.tensor
qscale: torch.tensor
qscale_max: float
maxq: float
scale_maxq: float
qzero: float
def __init__(self,
bits: int = 4,
scale_bits: int = 4):
self.bits = bits
self.scale_bits = scale_bits
self.maxq = 2 ** bits - 1
self.qzero = (self.maxq + 1) / 2
self.scale_maxq = 2 ** scale_bits - 1
self.scale_maxq = (2 ** self.scale_bits) - 1
def find_params(self, x):
xmax, _ = torch.max(torch.abs(x), dim = 0)
xmax += 1e-12
base_scale = xmax / (self.maxq / 2)
qscale_max_t = torch.max(base_scale) * self.scale_range
scale_tp = base_scale / qscale_max_t
scale_tp = torch.sqrt(scale_tp)
scale_tp *= (self.scale_maxq + 1)
qscale_t = torch.clamp(torch.round(scale_tp), 1, self.scale_maxq + 1)
qscale_tw = qscale_t / (self.scale_maxq + 1)
qscale_tw = qscale_tw ** 2
qscale_tw *= qscale_max_t
q = torch.zeros((self.p_grid + 1, 128), dtype = torch.float, device = x.device)
ext_c.quantize_err(x, q, qscale_tw, self.qzero, self.maxq, self.norm, self.min_p, self.max_p, self.p_grid)
q = torch.sum(q, dim = 1)
best_pi = torch.argmin(q)
best_pif = best_pi / self.p_grid
best_p = self.max_p * best_pif + self.min_p * (1 - best_pif)
# best_p = 1.0
self.qscale = qscale_t.to(torch.short)
self.scale = qscale_tw * best_p
self.qscale_max = qscale_max_t * best_p
class AdaptiveGPTQ:
percdamp: float = 0.07
layer: nn.Linear
device: torch.device
group_size: int
bits: list
bits_groups: list
scale_bits: int
hot_bits: int
columns: int
rows: int
hessian: torch.tensor
total_groups: int
perm: torch.tensor = None
invperm: torch.tensor = None
g_idx: torch.tensor = None
scale: torch.tensor = None
qscale: torch.tensor = None
qscale_max: torch.tensor = None
qweight: torch.tensor = None
qgroups: torch.tensor = None
quant: torch.tensor = None
weights: torch.tensor = None
hessian: torch.tensor = None
hessian_inv: torch.tensor = None
num_samples: int = 0
num_batches: int = 0
def __init__(self,
layer: nn.Linear):
self.layer = layer
self.device = layer.weight.device
self.rows = self.layer.weight.data.shape[1]
self.columns = self.layer.weight.data.shape[0]
self.weights = self.layer.weight.data.T.clone().float().contiguous()
self.hessian = None
self.num_samples = 0
self.num_batches = 0
def drop_buffers(self):
self.perm = None
self.invperm = None
self.g_idx = None
self.scale = None
self.qscale = None
self.qscale_max = None
self.qweight = None
self.qgroups = None
self.quant = None
self.weights = None
self.hessian = None
self.hessian_inv = None
gc.collect()
torch.cuda.empty_cache()
def configure(self,
group_size: dict,
bits = None,
bits_prop = None,
scale_bits: int = 4
):
self.group_size = group_size
self.scale_bits = scale_bits
self.bits = bits
assert isinstance(bits, list)
assert isinstance(bits_prop, list)
assert sum(bits_prop) == 1
groups = 0
remaining_rows = self.rows
self.bits_groups = []
for b, p in zip(self.bits, bits_prop):
assert p > 0
gsz = self.group_size[b]
g = math.ceil(min(self.rows * p, remaining_rows) / gsz)
groups += g
remaining_rows -= g * gsz
self.bits_groups.append(g)
assert remaining_rows <= 0
self.total_groups = groups
# if isinstance(bits, list):
#
# self.bits = bits
# g128 = (self.rows + 128 - 1) // 128
# self.bits_groups = [max(round(g128 * p), 1) * 128 // self.group_size for p in bits_prop]
# e = sum(self.bits_groups) - self.total_groups
# self.bits_groups[-1] -= e
#
# else:
#
# self.bits = [bits]
# self.bits_groups = [self.total_groups]
# def num_bits(self, subtract_columns = 0):
#
# gi = self.g_idx.numel() * 32
# qs = self.qscale.numel() * self.scale_bits
# qss = self.qscale_max.numel() * 16
#
# w = 0
# tr = self.rows
# for g, b in zip(self.bits_groups, self.bits):
#
# c = self.columns - subtract_columns
# r = self.group_size * g
# if r > tr: r = tr
# tr -= r
# w += r * c * b
#
# return w + gi + qs + qss
def add_batch(self, inputs):
with torch.inference_mode():
if self.hessian is None:
self.hessian = torch.zeros((self.rows, self.rows), device=self.device, dtype=torch.float)
self.num_batches += 1
num_samples = len(inputs)
inputs = torch.cat(inputs, dim = 0)
inputs = inputs.view((-1, inputs.shape[-1])).float().T.to("cuda:0")
inputs *= math.sqrt(2 / num_samples)
self.hessian += inputs.matmul(inputs.T)
def prepare(self):
with torch.inference_mode():
self.hessian /= self.num_batches
diagonal = torch.diag(self.hessian)
# Zero weights that have no impact. Disabling this since it feels a little drastic based on just the calibration
# data. It likely never triggers, anyway.
# dead = diagonal == 0.0
# self.hessian[dead, dead] = 1
# self.weights[dead, :] = 0
# Activation order
self.perm = torch.argsort(diagonal, descending = True)
self.weights = self.weights[self.perm, :]
hessian = self.hessian[self.perm][:, self.perm]
self.hessian = None
# In case numerical errors have caused some asymmetry in H, assume it's close to symmetrical and force it.
# (Doesn't seem to be needed)
# torch.cuda.empty_cache()
# hessian = (hessian + hessian.T) * 0.5
# torch.cuda.empty_cache()
# Damping
diagonal = torch.diag(hessian)
damp = torch.clamp(self.percdamp * torch.mean(diagonal), min = 1e-5)
# Inverse of H
attempts = 0
while True:
try:
d = torch.arange(self.rows, device = self.device)
hessian[d, d] += damp
# Dump condition number and smallest eigenvalue (should be positive)
# fro_norm_hessian = torch.norm(hessian, p = 'fro')
# fro_norm_inv = torch.norm(torch.linalg.inv(hessian), p = 'fro')
# cond_number = fro_norm_hessian * fro_norm_inv
# print(cond_number)
# eigenvalues = torch.linalg.eigvalsh(hessian)
# is_pd = torch.all(eigenvalues > 0)
# print(is_pd)
# print(torch.min(eigenvalues))
hessian_inv = torch.linalg.cholesky(hessian)
hessian_inv = torch.cholesky_inverse(hessian_inv)
# The Cholesky inverse will sometimes fail to compute due to accumulated rounding errors when H
# is very large (e.g. 70B MLP down proj) and a lot of calibration data is used (e.g. 100 rows of
# 4096 tokens). This won't always throw an exception and sometimes just results in a NaN tensor.
if torch.any(torch.isnan(hessian_inv)): raise RuntimeError
# Test inversion
# test = hessian_inv @ hessian
# test.sub_(torch.eye(test.size(0), device = test.device, dtype = test.dtype))
# test **= 2
# test = test.mean()
# print(test)
hessian_inv = torch.linalg.cholesky(hessian_inv, upper = True)
hessian_inv = hessian_inv.contiguous()
break
except RuntimeError:
# If inverting failed, assume there were non-positive eigenvalues, so apply more damping to shift
# the eigenvalues in a positive direction.
print(" !! Warning: Applied additional damping")
attempts += 1
if attempts == 10:
raise ValueError("Hessian is not invertible")
self.hessian_inv = hessian_inv
self.hessian = None
def reuse_h(self, other):
with torch.inference_mode():
self.hessian_inv = other.hessian_inv
self.hessian = None
self.perm = other.perm
self.weights = self.weights[self.perm, :]
def quantize(self, keep_qweight = False, apply = False, drop = False):
with torch.inference_mode():
if apply:
weights = self.weights
self.layer.weight.data = torch.zeros((1, 1), dtype = torch.float32, device = weights.device)
else:
weights = self.weights.clone()
self.quant = torch.zeros_like(self.weights)
if keep_qweight:
self.qweight = torch.zeros_like(weights, dtype = torch.short)
# Quantize groups
scale = []
qscale = []
qscale_max = []
qgroups = []
error = weights.clone()
group_idx = 0
group_idx_list = []
b = 0
for bits_idx, bits in enumerate(self.bits):
quantizer = AdaptiveQuantizer(bits = bits, scale_bits = self.scale_bits)
for group in range(self.bits_groups[bits_idx]):
a = b
b = min(a + self.group_size[bits], self.rows)
qgroups.append(bits)
qgroups.append(0)
quantizer.find_params(weights[a : b, :])
scale.append(quantizer.scale)
qscale.append(quantizer.qscale)
qscale_max.append(quantizer.qscale_max)
ext_c.quantize_range(self.quant,
quantizer.scale,
self.qweight if keep_qweight else none_tensor,
quantizer.qzero,
quantizer.maxq,
self.hessian_inv,
weights,
error,
a,
b)
group_idx_list += [group_idx] * (b - a)
group_idx += 1
# Create g_idx to store inverse activation order
self.g_idx = torch.tensor(group_idx_list, dtype = torch.int32, device = self.device)
self.invperm = torch.argsort(self.perm)
self.g_idx = self.g_idx[self.invperm]
# Store scales
self.scale = torch.stack(scale, dim = 0)
self.qscale = torch.stack(qscale, dim = 0)
self.qscale_max = torch.tensor(qscale_max, dtype = torch.float16, device = self.device)
self.qgroups = torch.tensor(qgroups, dtype = torch.short, device = self.device)
# Apply
if apply:
if drop:
weights = None
error = None
scale = None
qscale = None
qscale_max = None
qgroups = None
group_idx_list = None
gc.collect()
torch.cuda.empty_cache()
self.apply_quant()
def quant_error(self):
with torch.inference_mode():
q = self.quant[self.invperm, :]
diff = torch.abs(q - self.layer.weight.data.T)
mat_error_1 = (diff > 0.01).sum().item() / diff.numel()
mat_error_5 = (diff > 0.05).sum().item() / diff.numel()
mat_error_10 = (diff > 0.10).sum().item() / diff.numel()
return mat_error_1, mat_error_5, mat_error_10
def apply_quant(self):
qc = self.quant.cpu()
invperm = self.invperm.cpu()
q = qc[invperm, :].T
q = q.reshape(self.quant.T.shape)
q = q.to(self.quant.device)
self.layer.weight.data = q
def apply_temp(self):
q = self.quant[self.invperm, :].T
temp_layer = nn.Linear(self.layer.in_features, self.layer.out_features, False, device = "meta", dtype = torch.float16)
temp_layer.weight = nn.Parameter(q.reshape(self.layer.weight.shape).type_as(self.layer.weight.data))
return temp_layer
def pack(self, key, qparams):
assert qparams.scale_bits in [4]
# assert self.columns % 32 == 0
output = {}
output[key + ".q_invperm"] = self.invperm.to(torch.int)
output[key + ".q_scale_max"] = self.qscale_max
output[key + ".q_groups"] = self.qgroups
columns = self.columns
rem_rows = self.rows
padding = -columns % 32
if padding != 0:
print(f" !! Note: Padding quantized tensor {key}")
qst = F.pad(self.qscale, (0, padding)).contiguous()
qwt = F.pad(self.qweight, (0, padding)).contiguous()
else:
qst = self.qscale
qwt = self.qweight
qst_packed = torch.zeros((qst.shape[0], qst.shape[1] * qparams.scale_bits // 32), dtype = torch.int32, device = self.device)
if qparams.scale_bits == 4: ext_c.pack_rows_4(qst, qst_packed)
# if qparams.scale_bits == 6: ext_c.pack_rows_6(qst, qst_packed) # TODO:
output[key + ".q_scale"] = qst_packed
qwt_packed = []
i = 0
row = 0
out_row = 0
while i < self.qscale.shape[0]:
bits = self.qgroups[i * 2].item()
self.qgroups[i * 2 + 1] = out_row
i += 1
rows = min(self.group_size[bits], rem_rows)
wpqr = 32 / bits
qrows = rows / wpqr
assert i == self.qgroups.shape[-1] or qrows == int(qrows)
qrows = math.ceil(qrows)
g_qwt = qwt[row:row+rows, :].contiguous()
g_qwt_packed = torch.zeros((qrows, columns + padding), dtype = torch.int32, device = self.device)
if padding > 0: g_qwt[:, -padding:] = 2 ** (bits - 1)
ext_c.pack_columns(g_qwt, g_qwt_packed, bits)
qwt_packed.append(g_qwt_packed)
# print(row, rows, bits)
row += rows
out_row += qrows
rem_rows -= rows
qwt_packed = torch.cat(qwt_packed, dim = 0)
output[key + ".q_weight"] = qwt_packed
return output
This page shows examples of messages formatted using JSON (JavaScript Object Notation).
{
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
}
}
}
}
}
The same text expressed as XML:
<!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook V3.1//EN">
<glossary><title>example glossary</title>
<GlossDiv><title>S</title>
<GlossList>
<GlossEntry ID="SGML" SortAs="SGML">
<GlossTerm>Standard Generalized Markup Language</GlossTerm>
<Acronym>SGML</Acronym>
<Abbrev>ISO 8879:1986</Abbrev>
<GlossDef>
<para>A meta-markup language, used to create markup
languages such as DocBook.</para>
<GlossSeeAlso OtherTerm="GML">
<GlossSeeAlso OtherTerm="XML">
</GlossDef>
<GlossSee OtherTerm="markup">
</GlossEntry>
</GlossList>
</GlossDiv>
</glossary>
{"menu": {
"id": "file",
"value": "File",
"popup": {
"menuitem": [
{"value": "New", "onclick": "CreateNewDoc()"},
{"value": "Open", "onclick": "OpenDoc()"},
{"value": "Close", "onclick": "CloseDoc()"}
]
}
}}
The same text expressed as XML:
<menu id="file" value="File">
<popup>
<menuitem value="New" onclick="CreateNewDoc()" />
<menuitem value="Open" onclick="OpenDoc()" />
<menuitem value="Close" onclick="CloseDoc()" />
</popup>
</menu>
{"widget": {
"debug": "on",
"window": {
"title": "Sample Konfabulator Widget",
"name": "main_window",
"width": 500,
"height": 500
},
"image": {
"src": "Images/Sun.png",
"name": "sun1",
"hOffset": 250,
"vOffset": 250,
"alignment": "center"
},
"text": {
"data": "Click Here",
"size": 36,
"style": "bold",
"name": "text1",
"hOffset": 250,
"vOffset": 100,
"alignment": "center",
"onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
}
}}
The same text expressed as XML:
<widget>
<debug>on</debug>
<window title="Sample Konfabulator Widget">
<name>main_window</name>
<width>500</width>
<height>500</height>
</window>
<image src="Images/Sun.png" name="sun1">
<hOffset>250</hOffset>
<vOffset>250</vOffset>
<alignment>center</alignment>
</image>
<text data="Click Here" size="36" style="bold">
<name>text1</name>
<hOffset>250</hOffset>
<vOffset>100</vOffset>
<alignment>center</alignment>
<onMouseUp>
sun1.opacity = (sun1.opacity / 100) * 90;
</onMouseUp>
</text>
</widget>
{"web-app": {
"servlet": [
{
"servlet-name": "cofaxCDS",
"servlet-class": "org.cofax.cds.CDSServlet",
"init-param": {
"configGlossary:installationAt": "Philadelphia, PA",
"configGlossary:adminEmail": "[email protected]",
"configGlossary:poweredBy": "Cofax",
"configGlossary:poweredByIcon": "/images/cofax.gif",
"configGlossary:staticPath": "/content/static",
"templateProcessorClass": "org.cofax.WysiwygTemplate",
"templateLoaderClass": "org.cofax.FilesTemplateLoader",
"templatePath": "templates",
"templateOverridePath": "",
"defaultListTemplate": "listTemplate.htm",
"defaultFileTemplate": "articleTemplate.htm",
"useJSP": false,
"jspListTemplate": "listTemplate.jsp",
"jspFileTemplate": "articleTemplate.jsp",
"cachePackageTagsTrack": 200,
"cachePackageTagsStore": 200,
"cachePackageTagsRefresh": 60,
"cacheTemplatesTrack": 100,
"cacheTemplatesStore": 50,
"cacheTemplatesRefresh": 15,
"cachePagesTrack": 200,
"cachePagesStore": 100,
"cachePagesRefresh": 10,
"cachePagesDirtyRead": 10,
"searchEngineListTemplate": "forSearchEnginesList.htm",
"searchEngineFileTemplate": "forSearchEngines.htm",
"searchEngineRobotsDb": "WEB-INF/robots.db",
"useDataStore": true,
"dataStoreClass": "org.cofax.SqlDataStore",
"redirectionClass": "org.cofax.SqlRedirection",
"dataStoreName": "cofax",
"dataStoreDriver": "com.microsoft.jdbc.sqlserver.SQLServerDriver",
"dataStoreUrl": "jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon",
"dataStoreUser": "sa",
"dataStorePassword": "dataStoreTestQuery",
"dataStoreTestQuery": "SET NOCOUNT ON;select test='test';",
"dataStoreLogFile": "/usr/local/tomcat/logs/datastore.log",
"dataStoreInitConns": 10,
"dataStoreMaxConns": 100,
"dataStoreConnUsageLimit": 100,
"dataStoreLogLevel": "debug",
"maxUrlLength": 500}},
{
"servlet-name": "cofaxEmail",
"servlet-class": "org.cofax.cds.EmailServlet",
"init-param": {
"mailHost": "mail1",
"mailHostOverride": "mail2"}},
{
"servlet-name": "cofaxAdmin",
"servlet-class": "org.cofax.cds.AdminServlet"},
{
"servlet-name": "fileServlet",
"servlet-class": "org.cofax.cds.FileServlet"},
{
"servlet-name": "cofaxTools",
"servlet-class": "org.cofax.cms.CofaxToolsServlet",
"init-param": {
"templatePath": "toolstemplates/",
"log": 1,
"logLocation": "/usr/local/tomcat/logs/CofaxTools.log",
"logMaxSize": "",
"dataLog": 1,
"dataLogLocation": "/usr/local/tomcat/logs/dataLog.log",
"dataLogMaxSize": "",
"removePageCache": "/content/admin/remove?cache=pages&id=",
"removeTemplateCache": "/content/admin/remove?cache=templates&id=",
"fileTransferFolder": "/usr/local/tomcat/webapps/content/fileTransferFolder",
"lookInContext": 1,
"adminGroupID": 4,
"betaServer": true}}],
"servlet-mapping": {
"cofaxCDS": "/",
"cofaxEmail": "/cofaxutil/aemail/*",
"cofaxAdmin": "/admin/*",
"fileServlet": "/static/*",
"cofaxTools": "/tools/*"},
"taglib": {
"taglib-uri": "cofax.tld",
"taglib-location": "/WEB-INF/tlds/cofax.tld"}}}
The same file expressed as XML:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2.2.dtd">
<web-app>
<servlet>
<servlet-name>
cofaxCDS
</servlet-name>
<servlet-class>
org.cofax.cds.CDSServlet
</servlet-class>
<init-param>
<param-name>configGlossary:installationAt</param-name>
<param-value>Philadelphia, PA</param-value>
</init-param>
<init-param>
<param-name>configGlossary:adminEmail</param-name>
<param-value>[email protected]</param-value>
</init-param>
<init-param>
<param-name>configGlossary:poweredBy</param-name>
<param-value>Cofax</param-value>
</init-param>
<init-param>
<param-name>configGlossary:poweredByIcon</param-name>
<param-value>/images/cofax.gif</param-value>
</init-param>
<init-param>
<param-name>configGlossary:staticPath</param-name>
<param-value>/content/static</param-value>
</init-param>
<init-param>
<param-name>templateProcessorClass</param-name>
<param-value>org.cofax.WysiwygTemplate</param-value>
</init-param>
<init-param>
<param-name>templateLoaderClass</param-name>
<param-value>org.cofax.FilesTemplateLoader</param-value>
</init-param>
<init-param>
<param-name>templatePath</param-name>
<param-value>templates</param-value>
</init-param>
<init-param>
<param-name>templateOverridePath</param-name>
<param-value></param-value>
</init-param>
<init-param>
<param-name>defaultListTemplate</param-name>
<param-value>listTemplate.htm</param-value>
</init-param>
<init-param>
<param-name>defaultFileTemplate</param-name>
<param-value>articleTemplate.htm</param-value>
</init-param>
<init-param>
<param-name>useJSP</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>jspListTemplate</param-name>
<param-value>listTemplate.jsp</param-value>
</init-param>
<init-param>
<param-name>jspFileTemplate</param-name>
<param-value>articleTemplate.jsp</param-value>
</init-param>
<init-param>
<param-name>cachePackageTagsTrack</param-name>
<param-value>200</param-value>
</init-param>
<init-param>
<param-name>cachePackageTagsStore</param-name>
<param-value>200</param-value>
</init-param>
<init-param>
<param-name>cachePackageTagsRefresh</param-name>
<param-value>60</param-value>
</init-param>
<init-param>
<param-name>cacheTemplatesTrack</param-name>
<param-value>100</param-value>
</init-param>
<init-param>
<param-name>cacheTemplatesStore</param-name>
<param-value>50</param-value>
</init-param>
<init-param>
<param-name>cacheTemplatesRefresh</param-name>
<param-value>15</param-value>
</init-param>
<init-param>
<param-name>cachePagesTrack</param-name>
<param-value>200</param-value>
</init-param>
<init-param>
<param-name>cachePagesStore</param-name>
<param-value>100</param-value>
</init-param>
<init-param>
<param-name>cachePagesRefresh</param-name>
<param-value>10</param-value>
</init-param>
<init-param>
<param-name>cachePagesDirtyRead</param-name>
<param-value>10</param-value>
</init-param>
<init-param>
<param-name>searchEngineListTemplate</param-name>
<param-value>forSearchEnginesList.htm</param-value>
</init-param>
<init-param>
<param-name>searchEngineFileTemplate</param-name>
<param-value>forSearchEngines.htm</param-value>
</init-param>
<init-param>
<param-name>searchEngineRobotsDb</param-name>
<param-value>WEB-INF/robots.db</param-value>
</init-param>
<init-param>
<param-name>useDataStore</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>dataStoreClass</param-name>
<param-value>org.cofax.SqlDataStore</param-value>
</init-param>
<init-param>
<param-name>redirectionClass</param-name>
<param-value>org.cofax.SqlRedirection</param-value>
</init-param>
<init-param>
<param-name>dataStoreName</param-name>
<param-value>cofax</param-value>
</init-param>
<init-param>
<param-name>dataStoreDriver</param-name>
<param-value>com.microsoft.jdbc.sqlserver.SQLServerDriver</param-value>
</init-param>
<init-param>
<param-name>dataStoreUrl</param-name>
<param-value>jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon</param-value>
</init-param>
<init-param>
<param-name>dataStoreUser</param-name>
<param-value>sa</param-value>
</init-param>
<init-param>
<param-name>dataStorePassword</param-name>
<param-value></param-value>
</init-param>
<init-param>
<param-name>dataStoreTestQuery</param-name>
<param-value>SET NOCOUNT ON;select test='test';</param-value>
</init-param>
<init-param>
<param-name>dataStoreLogFile</param-name>
<param-value>/usr/local/tomcat/logs/datastore.log</param-value>
</init-param>
<init-param>
<param-name>dataStoreInitConns</param-name>
<param-value>10</param-value>
</init-param>
<init-param>
<param-name>dataStoreMaxConns</param-name>
<param-value>100</param-value>
</init-param>
<init-param>
<param-name>dataStoreConnUsageLimit</param-name>
<param-value>100</param-value>
</init-param>
<init-param>
<param-name>dataStoreLogLevel</param-name>
<param-value>debug</param-value>
</init-param>
<init-param>
<param-name>maxUrlLength</param-name>
<param-value>500</param-value>
</init-param>
</servlet>
<servlet>
<servlet-name>
cofaxEmail
</servlet-name>
<servlet-class>
org.cofax.cds.EmailServlet
</servlet-class>
<init-param>
<param-name>mailHost</param-name>
<param-value>mail1</param-value>
</init-param>
<init-param>
<param-name>mailHostOverride</param-name>
<param-value>mail2</param-value>
</init-param>
</servlet>
<servlet>
<servlet-name>
cofaxAdmin
</servlet-name>
<servlet-class>
org.cofax.cds.AdminServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>
fileServlet
</servlet-name>
<servlet-class>
org.cofax.cds.FileServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>
cofaxTools
</servlet-name>
<servlet-class>
org.cofax.cms.CofaxToolsServlet
</servlet-class>
<init-param>
<param-name>templatePath</param-name>
<param-value>toolstemplates/</param-value>
</init-param>
<init-param>
<param-name>log</param-name>
<param-value>1</param-value>
</init-param>
<init-param>
<param-name>logLocation</param-name>
<param-value>/usr/local/tomcat/logs/CofaxTools.log</param-value>
</init-param>
<init-param>
<param-name>logMaxSize</param-name>
<param-value></param-value>
</init-param>
<init-param>
<param-name>dataLog</param-name>
<param-value>1</param-value>
</init-param>
<init-param>
<param-name>dataLogLocation</param-name>
<param-value>/usr/local/tomcat/logs/dataLog.log</param-value>
</init-param>
<init-param>
<param-name>dataLogMaxSize</param-name>
<param-value></param-value>
</init-param>
<init-param>
<param-name>removePageCache</param-name>
<param-value>/content/admin/remove?cache=pages&id=</param-value>
</init-param>
<init-param>
<param-name>removeTemplateCache</param-name>
<param-value>/content/admin/remove?cache=templates&id=</param-value>
</init-param>
<init-param>
<param-name>fileTransferFolder</param-name>
<param-value>/usr/local/tomcat/webapps/content/fileTransferFolder</param-value>
</init-param>
<init-param>
<param-name>lookInContext</param-name>
<param-value>1</param-value>
</init-param>
<init-param>
<param-name>adminGroupID</param-name>
<param-value>4</param-value>
</init-param>
<init-param>
<param-name>betaServer</param-name>
<param-value>true</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>
cofaxCDS
</servlet-name>
<url-pattern>
/
</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>
cofaxEmail
</servlet-name>
<url-pattern>
/cofaxutil/aemail/*
</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>
cofaxAdmin
</servlet-name>
<url-pattern>
/admin/*
</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>
fileServlet
</servlet-name>
<url-pattern>
/static/*
</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>
cofaxTools
</servlet-name>
<url-pattern>
/tools/*
</url-pattern>
</servlet-mapping>
<taglib>
<taglib-uri>cofax.tld</taglib-uri>
<taglib-location>/WEB-INF/tlds/cofax.tld</taglib-location>
</taglib>
</web-app>
The action and label values only need to be provided if they are not the same as the id.
{"menu": {
"header": "SVG Viewer",
"items": [
{"id": "Open"},
{"id": "OpenNew", "label": "Open New"},
null,
{"id": "ZoomIn", "label": "Zoom In"},
{"id": "ZoomOut", "label": "Zoom Out"},
{"id": "OriginalView", "label": "Original View"},
null,
{"id": "Quality"},
{"id": "Pause"},
{"id": "Mute"},
null,
{"id": "Find", "label": "Find..."},
{"id": "FindAgain", "label": "Find Again"},
{"id": "Copy"},
{"id": "CopyAgain", "label": "Copy Again"},
{"id": "CopySVG", "label": "Copy SVG"},
{"id": "ViewSVG", "label": "View SVG"},
{"id": "ViewSource", "label": "View Source"},
{"id": "SaveAs", "label": "Save As"},
null,
{"id": "Help"},
{"id": "About", "label": "About Adobe CVG Viewer..."}
]
}}
The same message expressed as XML:
<menu>
<header>Adobe SVG Viewer</header>
<item action="Open" id="Open">Open</item>
<item action="OpenNew" id="OpenNew">Open New</item>
<separator/>
<item action="ZoomIn" id="ZoomIn">Zoom In</item>
<item action="ZoomOut" id="ZoomOut">Zoom Out</item>
<item action="OriginalView" id="OriginalView">Original View</item>
<separator/>
<item action="Quality" id="Quality">Quality</item>
<item action="Pause" id="Pause">Pause</item>
<item action="Mute" id="Mute">Mute</item>
<separator/>
<item action="Find" id="Find">Find...</item>
<item action="FindAgain" id="FindAgain">Find Again</item>
<item action="Copy" id="Copy">Copy</item>
<item action="CopyAgain" id="CopyAgain">Copy Again</item>
<item action="CopySVG" id="CopySVG">Copy SVG</item>
<item action="ViewSVG" id="ViewSVG">View SVG</item>
<item action="ViewSource" id="ViewSource">View Source</item>
<item action="SaveAs" id="SaveAs">Save As</item>
<separator/>
<item action="Help" id="Help">Help</item>
<item action="About" id="About">About Adobe CVG Viewer...</item>
</menu>
We have discussed qsort() in C. C++ STL provides a similar function sort that sorts a vector or array (items with random access)
It generally takes two parameters, the first one being the point of the array/vector from where the sorting needs to begin and the second parameter being the length up to which we want the array/vector to get sorted. The third parameter is optional and can be used in cases such as if we want to sort the elements lexicographically.
By default, the sort() function sorts the elements in ascending order.
Below is a simple program to show the working of sort().
// C++ program to demonstrate default behaviour of
// sort() in STL.
#include <bits/stdc++.h>
using namespace std;
int main()
{
int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int n = sizeof(arr) / sizeof(arr[0]);
/*Here we take two parameters, the beginning of the
array and the length n upto which we want the array to
be sorted*/
sort(arr, arr + n);
cout << "\nArray after sorting using "
"default sort is : \n";
for (int i = 0; i < n; ++i)
cout << arr[i] << " ";
return 0;
}
Output
Array after sorting using default sort is :
0 1 2 3 4 5 6 7 8 9
Time Complexity: O(N log N)
Auxiliary Space: O(1)
How to sort in descending order?
sort() takes a third parameter that is used to specify the order in which elements are to be sorted. We can pass the “greater()” function to sort in descending order. This function does a comparison in a way that puts greater elements before.
// C++ program to demonstrate descending order sort using
// greater<>().
#include <bits/stdc++.h>
using namespace std;
int main()
{
int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int n = sizeof(arr) / sizeof(arr[0]);
sort(arr, arr + n, greater<int>());
cout << "Array after sorting : \n";
for (int i = 0; i < n; ++i)
cout << arr[i] << " ";
return 0;
}
Output
Array after sorting :
9 8 7 6 5 4 3 2 1 0
Time Complexity: O(N log N)
Auxiliary Space: O(1)
Sort the array only in the given range: To deal with such types of problems we just have to mention the range inside the sort function.
Below is the implementation of above case:
// C++ program to demonstrate sort()
#include <bits/stdc++.h>
using namespace std;
int main()
{
int arr[] = { 0, 1, 5, 8, 9, 6, 7, 3, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
// Sort the elements which lies in the range of 2 to
// (n-1)
sort(arr + 2, arr + n);
cout << "Array after sorting : \n";
for (int i = 0; i < n; ++i)
cout << arr[i] << " ";
return 0;
}
// This code is contributed by Suruchi Kumari
Output
Array after sorting :
0 1 2 3 4 5 6 7 8 9
Time Complexity: O(N log N)
Auxiliary Space: O(1)
How to sort in a particular order?
We can also write our own comparator function and pass it as a third parameter. This “comparator” function returns a value; convertible to bool, which basically tells us whether the passed “first” argument should be placed before the passed “second” argument or not.
For eg: In the code below, suppose intervals {6,8} and {1,9} are passed as arguments in the “compareInterval” function(comparator function). Now as i1.first (=6) < i2.first (=1), so our function returns “false”, which tells us that “first” argument should not be placed before “second” argument and so sorting will be done in order like {1,9} first and then {6,8} as next.
// A C++ program to demonstrate
// STL sort() using
// our own comparator
#include <bits/stdc++.h>
using namespace std;
// An interval has a start
// time and end time
struct Interval {
int start, end;
};
// Compares two intervals
// according to starting times.
bool compareInterval(Interval i1, Interval i2)
{
return (i1.start < i2.start);
}
int main()
{
Interval arr[]
= { { 6, 8 }, { 1, 9 }, { 2, 4 }, { 4, 7 } };
int n = sizeof(arr) / sizeof(arr[0]);
// sort the intervals in increasing order of
// start time
sort(arr, arr + n, compareInterval);
cout << "Intervals sorted by start time : \n";
for (int i = 0; i < n; i++)
cout << "[" << arr[i].start << "," << arr[i].end
<< "] ";
return 0;
}
Output
Intervals sorted by start time :
[1,9] [2,4] [4,7] [6,8]
The time complexity of std::sort() is:
Best Case – O(N log N)
Average Case – O(N log N)
Worst-Case – O(N log N)
Space Complexity: It may use O( log N) auxiliary space.
#include <algorithm>
#include <iostream>
using namespace std;
template <class T>
class Comparator { // we pass an object of this class as
// third arg to sort function...
public:
bool operator()(T x1, T x2)
{
return x1 < x2;
}
};
template <class T> bool funComparator(T x1, T x2)
{ // return type is bool
return x1 <= x2;
}
void show(int a[], int array_size)
{
for (int i = 0; i < array_size; i++) {
cout << a[i] << " ";
}
}
int main()
{
int a[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int asize = sizeof(a) / sizeof(int);
cout << "The array before sorting is : ";
show(a, asize);
cout << endl << "The array after sorting is(asc) :";
sort(a, a + asize);
show(a, asize);
cout << endl << "The array after sorting is(desc) :";
sort(a, a + asize, greater<int>());
show(a, asize);
cout << endl
<< "The array after sorting is(asc but our "
"comparator class) :";
sort(a, a + asize, Comparator<int>());
show(a, asize);
cout << endl
<< "The array after sorting is(asc but our "
"comparator function) :";
sort(a, a + asize, funComparator<int>);
show(a, asize);
return 0;
}
Output
The array before sorting is : 1 5 8 9 6 7 3 4 2 0
The array after sorting is(asc) :0 1 2 3 4 5 6 7 8 9
The array after sorting is(desc) :9 8 7 6 5 4 3 2 1 0
The array after sorting is(asc but our comparator class) :0 1 2 3 4 5 6 7 8 9
The array after sorting is(asc but our comparator function) :0 1 2 3 4 5 6 7 8 9
Time Complexity: O(N log N)
Auxiliary Space: O(1)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
The following are different ways to construct or initialize a vector in C++ STL
1. Initializing by pushing values one by one:
// C++ program to create an empty
// vector and push values one
// by one.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Create an empty vector
vector<int> vect;
vect.push_back(10);
vect.push_back(20);
vect.push_back(30);
for (int x : vect)
cout << x << " ";
return 0;
}
Output
10 20 30
2. Specifying size and initializing all values:
// C++ program to create an empty
// vector and push values one
// by one.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n = 3;
// Create a vector of size n with
// all values as 10.
vector<int> vect(n, 10);
for (int x : vect)
cout << x << " ";
return 0;
}
Output
10 10 10
3. Initializing like arrays:
// C++ program to initialize
// a vector like an array.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vect{ 10, 20, 30 };
for (int x : vect)
cout << x << " ";
return 0;
}
Output
10 20 30
4. Initializing from an array:
// C++ program to initialize
// a vector from an array.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int arr[] = { 10, 20, 30 };
int n = sizeof(arr) / sizeof(arr[0]);
vector<int> vect(arr, arr + n);
for (int x : vect)
cout << x << " ";
return 0;
}
Output
10 20 30
5. Initializing from another vector:
// C++ program to initialize a vector from
// another vector.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vect1{ 10, 20, 30 };
vector<int> vect2(vect1.begin(), vect1.end());
for (int x : vect2)
cout << x << " ";
return 0;
}
Output
10 20 30
6. Initializing all elements with a particular value:
// C++ Program to initialize vector using fill()
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// creating array with size 10
vector<int> vect1(10);
// initializing using fill() function
int value = 5;
fill(vect1.begin(), vect1.end(), value);
// printing vector
for (int x : vect1)
cout << x << " ";
return 0;
}
Output
5 5 5 5 5 5 5 5 5 5
7. Initialize an array with consecutive numbers using std::iota:
// C++ program to initialize a
// vector with consecutive
// numbers
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main()
{
// declaring a vector with size 5
vector<int> vec(5);
// initializing using iota()
iota(vec.begin(), vec.end(), 1);
// printing the vector
for (int i = 0; i < 5; i++) {
cout << vec[i] << " ";
}
return 0;
}
Output
1 2 3 4 5
Time complexity: O(N), where N is the size of the vector.
Auxiliary space: O(N).
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.
Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!
How to Hide and Show a Console Window in C++?
Read
Discuss
Courses
Practice
The task is to hide and Show the console window of a C++ program. The program for the same is given below.
Note: The results of the following program can only be seen when it is executed on a console.
Example:
// C++ program to hide and show a console window
#include <iostream>
#include <windows.h>
using namespace std;
void countdown()
{
cout << "3" << endl;
Sleep(1000);
cout << "2" << endl;
Sleep(1000);
cout << "1" << endl;
Sleep(1000);
cout << "0" << endl;
}
int main()
{
countdown();
HWND window;
AllocConsole();
// You Can Find HANDLE of other windows too
window = FindWindowA("ConsoleWindowClass", NULL);
ShowWindow(window, 0);
countdown();
ShowWindow(window, 1);
}
Output:
Explanation: The above program counts from 3 to 1 before the Console Window disappears. After the window has disappeared, the ShowWindow helps the program so that the Console Window reappears again after counting from 3 to 1(executing the countdown function).
The execution of the program can be understood by understanding the key functions of the program.
#include<windows.h> – The windows.h header in C++ programming languages are specifically designed for windows and contain a very large number of windows specific functions.
AllocConsole()- AllocConsole initializes standard input, standard output, and standard error handles for the new console.
ShowWindow()- Sets the specified window’s show state.
FindWindowA()– Takes string parameters and checks whose class name and window name match the specified strings
Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!
Last Updated : 27 Nov, 2022
Prerequisite: Templates in C++
Substitution Failure Is Not An Error (SFINAE) is a principle of the C++ programming language that states that a compiler should not fail to compile a program just because it cannot substitute a template parameter. This principle allows for the use of template metaprogramming and enables the compiler to make decisions based on the types of template arguments, which can be useful when dealing with complex code and difficult to reason about logic.
At its core, SFINAE is a way of allowing a compiler to decide which template to use in a given context. The decision is based on the types of template arguments and the compiler will choose the template that is most appropriate for the arguments.
Advantages of SFINAE:
SFINAE is useful in a variety of scenarios, including writing generic code and dealing with complex logic.
SFINAE allows the compiler to decide which template to use, it allows programmers to write code that can be reused in different contexts without needing to explicitly specify the types of template parameters.
SFINAE allows for better code reuse, as the same code can be used for different types of objects and parameters.
SFINAE also allows for better control over code complexity by allowing the compiler to make decisions based on the types of template parameters, it can reduce the amount of complex logic that needs to be written and understood.
SFINAE helps to make code more readable and maintainable, as it is easier to follow the logic of the program.
In conclusion, SFINAE is a powerful concept in C++ programming that allows for better code reuse, improved code readability, and better control over code complexity. It is a key component of template metaprogramming and is an essential tool for writing robust and efficient code.
Example:
// C++ Program to implement
// Substitution Failure Is Not An Error
#include <iostream>
#include <type_traits>
using namespace std;
// USing template to avoid errors
template <typename T>
void print_type(T t)
{
// For integer
if (is_integral<T>::value) {
cout << "T is an integral type" << endl;
}
// For floating number
else if (is_floating_point<T>::value) {
cout << "T is a floating point type" << endl;
}
// All other
else {
cout << "T is not an integral"
<< "or floating point type" << endl;
}
}
// Driver Code
int main()
{
// T is an integral type
print_type(10);
// T is a floating point type
print_type(10.5f);
// T is an integral type
print_type(true);
// T is an integral type
print_type('a');
// T is not an integral
// or floating point type
print_type("GFG");
return 0;
}
Output
T is an integral type
T is a floating point type
T is an integral type
T is an integral type
T is not an integralor floating point type
In this example, the print_type() function is a template function that takes a single argument of type T. Inside the function, there are if statements that use the is_integral and is_floating_point type traits to check the type of T. If T is of the expected type, the corresponding branch of the if statement is executed and the appropriate message is printed. If T is not of the expected type, the else branch is executed and the message “T is not an integral or floating point type” is printed.
SFINAE is used in this example because the if statement uses type traits to check the type of T, and if T is not of the expected type, the template substitution will fail. However, because SFINAE is in effect, this failure is not treated as a compile-time error, and the else branch is executed instead.
Disadvantages of SFINAE
Although SFINAE is very useful it comes with its own limitations, these are :
It can be difficult to debug and understand the underlying code, as it relies heavily on the templates and multiple overloads to work correctly.
SFINAE is not widely used and can be difficult to find documentation and tutorials for.
SFINAE can produce unexpected behavior, as it relies on the compiler to determine which template to use based on the given types. This can lead to unexpected results if the compiler chooses the wrong template.
SFINAE can also be slow, as it involves multiple checks in order to determine the correct template. This can lead to a performance hit if used in a critical section of code.
There are other methods to perform the same task one of which is enable_if
Enable_if (Syntax)
template<typename T>
enable_if_t<is_integral<T>, void> f(T x)
{
// code that only applies to integral tmodule jinvertertb;
reg a;
wire y;
//Design Instance
jinverter jinv(y,a);
initial
begin
$display ("RESULT\ta\ty");
a = 1; # 100; // Another value
if ( y == 0 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 0; # 100; // Initial value is set
if ( y == 1 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 1; # 50; // Another value
if ( y == 0 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 0; # 100; // Initial value is set
if ( y == 1 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
end
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
endmoduleypes goes here
}
module jinvertertb;
reg a;
wire y;
//Design Instance
jinverter jinv(y,a);
initial
begin
$display ("RESULT\ta\ty");
a = 1; # 100; // Another value
if ( y == 0 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 0; # 100; // Initial value is set
if ( y == 1 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 1; # 50; // Another value
if ( y == 0 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
a = 0; # 100; // Initial value is set
if ( y == 1 ) // Test for inversion
$display (" PASS \t%d\t%d",a,y);
else
$display (" FAIL \t%d\t%d",a,y);
end
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
endmodule
module jFIFOTb;
wire [7:0] DATAOUT;
wire full, empty;
reg clock, reset, wn, rn;
reg [7:0] DATAIN;
jFIFO jfifo(DATAOUT, full, empty, clock, reset, wn, rn, DATAIN);
//enabling the wave dump
initial begin
$dumpfile("dump.vcd"); $dumpvars;
end
initial
begin
clock = 0; DATAIN = 8'd0;
reset = 1; clock = 1; #5 ; clock = 0; #5;
reset = 0;
$display("Start testing");
// First write some data into the queue
wn = 1; rn = 0;
DATAIN = 8'd100;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd150;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd200;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd40;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd70;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd65;
clock = 1; #5 ; clock = 0; #5;
DATAIN = 8'd15;
clock = 1; #5 ; clock = 0; #5;
// Now start reading and checking the values
wn = 0; rn = 1;
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd100 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd150 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd200 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd40 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd70 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd65 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( DATAOUT === 8'd15 )
$display("PASS %p ", DATAOUT);
else
$display("FAIL %p ", DATAOUT);
clock = 1; #5 ; clock = 0; #5;
if ( empty === 1 )
$display("PASS %p ", empty);
else
$display("FAIL %p ", empty);
end
endmodule
To understand this example, you should have the knowledge of the following Java programming topics:
Java for Loop
Java while and do...while Loop
The factorial of a positive number n is given by:
factorial of n (n!) = 1 * 2 * 3 * 4 * ... * n
Example 1: Find Factorial of a number using for loop
public class Factorial {
public static void main(String[] args) {
int num = 10;
long factorial = 1;
for(int i = 1; i <= num; ++i)
{
// factorial = factorial * i;
factorial *= i;
}
System.out.printf("Factorial of %d = %d", num, factorial);
}
}
Output
Factorial of 10 = 3628800
In this program, we've used for loop to loop through all numbers between 1 and the given number num (10), and the product of each number till num is stored in a variable factorial.
We've used long instead of int to store large results of factorial. However, it's still not big enough to store the value of bigger numbers (say 100).
For results that cannot be stored in a long variable, we use BigInteger variable declared in java.math library.
Example 2: Find Factorial of a number using BigInteger
import java.math.BigInteger;
public class Factorial {
public static void main(String[] args) {
int num = 30;
BigInteger factorial = BigInteger.ONE;
for(int i = 1; i <= num; ++i)
{
// factorial = factorial * i;
factorial = factorial.multiply(BigInteger.valueOf(i));
}
System.out.printf("Factorial of %d = %d", num, factorial);
}
}
Output
Factorial of 30 = 265252859812191058636308480000000
Here, instead of long, we use BigInteger variable factorial.
Since, * cannot be used with BigInteger, we instead use multiply() for the product. Also, num should be casted to BigInteger for multiplication.
Likewise, we can also use a while loop to solve this problem.
Example 3: Find Factorial of a number using while loop
public class Factorial {
public static void main(String[] args) {
int num = 5, i = 1;
long factorial = 1;
while(i <= num)
{
factorial *= i;
i++;
}
System.out.printf("Factorial of %d = %d", num, factorial);
}
}
Output
Factorial of 5 = 120
In the above program, unlike a for loop, we have to increment the value of i inside the body of the loop.
Though both programs are technically correct, it is better to use for loop in this case. It's because the number of iteration (upto num) is known.
Visit this page to learn to find factorial of a number using recursion.
Java Program to Check Whether a Number can be Expressed as Sum of Two Prime Numbers
To understand this example, you should have the knowledge of the following Java programming topics:
Java Methods
Java for Loop
Java if...else Statement
Example: Represent a number as Sum of Two Prime Numbers
public class Main {
public static void main(String[] args) {
int number = 34;
boolean flag = false;
for (int i = 2; i <= number / 2; ++i) {
// condition for i to be a prime number
if (checkPrime(i)) {
// condition for n-i to be a prime number
if (checkPrime(number - i)) {
// n = primeNumber1 + primeNumber2
System.out.printf("%d = %d + %d\n", number, i, number - i);
flag = true;
}
}
}
if (!flag)
System.out.println(number + " cannot be expressed as the sum of two prime numbers.");
}
// Function to check prime number
static boolean checkPrime(int num) {
boolean isPrime = true;
for (int i = 2; i <= num / 2; ++i) {
if (num % i == 0) {
isPrime = false;
break;
}
}
return isPrime;
}
}
Run Code
Output
34 = 3 + 31
34 = 5 + 29
34 = 11 + 23
34 = 17 + 17
In the above example, we have created the checkPrime() method to find whether a number is prime or not. The method returns true if the passed number is prime.
Here, we have a number 34. The program tries to check if 34 can be represented as the sum of two prime numbers.
Working of Program
First, we run a for loop from i = 2 to number / 2.
Inside the for loop, we used two if statements. The first statement checks if i is prime or not.
If true, the second if statement checks if number - i is prime or not. This is because the sum of i and number - i is equal to number.
If the second statement is also true, then we can say the number 34 is a valid sum of two prime numbers.
// Java Program to Check if Given Integer is Odd or Even
// Using Brute Forcew Approach
// Importing required classes
import java.io.*;
import java.util.Scanner;
// Main class
class GFG {
// Main Driver Method
public static void main(String[] args)
{
// Declaring and initializing integer variable
int num = 10;
// Checking if number is even or odd number
// via remainder
if (num % 2 == 0) {
// If remainder is zero then this number is even
System.out.println("Entered Number is Even");
}
else {
// If remainder is not zero then this number is
// odd
System.out.println("Entered Number is Odd");
}
}
}
// Java Program to find even sum of
// fibonacci Series Till number N
import java.io.*;
class geeksforgeeks {
// Computing the value of first fibonacci series
// and storing the sum of even indexed numbers
static int Fib_Even_Sum(int N)
{
if (N <= 0)
return 0;
int fib[] = new int[2 * N + 1];
fib[0] = 0;
fib[1] = 1;
// Initializing the sum
int s = 0;
// Adding remaining numbers
for (int j = 2; j <= 2 * N; j++) {
fib[j] = fib[j - 1] + fib[j - 2];
// Only considering even indexes
if (j % 2 == 0)
s += fib[j];
}
return s;
}
// The Driver code
public static void main(String[] args)
{
int N = 11;
// Prints the sum of even-indexed numbers
System.out.println(
"Even sum of fibonacci series till number " + N
+ " is: " + +Fib_Even_Sum(N));
}
}
It can be clearly seen that the required sum can be obtained thus:
2 ( F2 + F4 + F6 +………+ F2n ) = (F1 + F2 + F3 + F4 +………+ F2n) – (F1 – F2 + F3 – F4 +………+ F2n)
Now the first term can be obtained if we put 2n instead of n in the formula given here.
Thus F1 + F2 + F3 + F4 +………+ F2n = F2n+2 – 1.
The second term can also be found if we put 2n instead of n in the formula given here
Thus, F1 – F2 + F3 – F4 +………- F2n = 1 + (-1)2n+1F2n-1 = 1 – F2n-1.
So, 2 ( F2 + F4 + F6 +………+ F2n)
= F2n+2 – 1 – 1 + F2n-1
= F2n+2 + F2n-1 – 2
= F2n + F2n+1 + F2n+1 – F2n – 2
= 2 ( F2n+1 -1)
Hence, ( F2 + F4 + F6 +………+ F2n) = F2n+1 -1 .
// Java Program to find even indexed
// Fibonacci Sum in O(Log n) time.
class GFG {
static int MAX = 1000;
// Create an array for memoization
static int f[] = new int[MAX];
// Returns n'th Fibonacci number
// using table f[]
static int fib(int n)
{
// Base cases
if (n == 0) {
return 0;
}
if (n == 1 || n == 2) {
return (f[n] = 1);
}
// If fib(n) is already computed
if (f[n] == 1) {
return f[n];
}
int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2;
// Applying above formula [Note value n&1 is 1
// if n is odd, else 0].
f[n] = (n % 2 == 1)
? (fib(k) * fib(k)
+ fib(k - 1) * fib(k - 1))
: (2 * fib(k - 1) + fib(k)) * fib(k);
return f[n];
}
// Computes value of even-indexed Fibonacci Sum
static int calculateEvenSum(int n)
{
return (fib(2 * n + 1) - 1);
}
// Driver program to test above function
public static void main(String[] args)
{
// Get n
int n = 11;
// Find the alternating sum
System.out.println(
"Even indexed Fibonacci Sum upto " + n
+ " terms: " + calculateEvenSum(n));
}
}
SCREEN 13
z = 1 / 100
FOR i = 0 TO 255
PALETTE i, INT(i / 4) + INT(i / 4) * 256 + INT(i / 4) * 65536
NEXT
DO
y = 1
dy = 0
ox = 0: oy = 1
FOR x = 1 TO 430
IF y > 0 THEN dy = dy - 1 / 4000
IF y < 0 THEN dy = dy + z
y = y + dy
a = POINT(x, 100 + y * 50)
a = a + 1
IF a > 255 THEN a = 255
PSET (x, 100 + y * 50), a
NEXT
z = z - 1 / 10000
LOOP
DIM bodyx(70)
DIM bodyy(70)
DIM bodyvx(70)
DIM bodyvy(70)
DIM obodyx(70)
DIM obodyy(70)
RANDOMIZE TIMER
bodies = 30
FOR i = 1 TO bodies
bodyx(i) = 620 * RND + 10
bodyy(i) = 400 * RND + 30
bodyvx(i) = RND - .5
bodyvy(i) = RND - .5
NEXT
SCREEN 12
PRINT "...."
WHILE INKEY$ = "": WEND
CLS
DO
' apply gravity
FOR i = 1 TO bodies
bodyvy(i) = bodyvy(i) + .001
NEXT
' adjust distances
FOR i = 1 TO bodies
FOR j = 1 TO bodies
IF i <> j THEN
centx = (bodyx(i) + bodyx(j)) * .5
centy = (bodyy(i) + bodyy(j)) * .5
distx = (bodyx(i) - bodyx(j)) / 2
disty = (bodyy(i) - bodyy(j)) / 2
distf = SQR(distx * distx + disty * disty)
mx = distx / distf
my = disty / distf
bodyvx(i) = bodyvx(i) - mx * (distf - 50) / 100
bodyvy(i) = bodyvy(i) - my * (distf - 50) / 100
END IF
NEXT
NEXT
' collide with ground
FOR i = 1 TO bodies
IF bodyy(i) + bodyvy(i) > 440 OR bodyy(i) + bodyvy(i) < 5 THEN
bodyvy(i) = -bodyvy(i) * 0!
bodyvx(i) = bodyvx(i) * 0!
END IF
IF bodyx(i) + bodyvx(i) > 625 OR bodyx(i) + bodyvx(i) < 15 THEN
bodyvx(i) = -bodyvx(i) * 0!
bodyvy(i) = bodyvy(i) * 0!
END IF
NEXT
' move bodies
FOR i = 1 TO bodies
obodyx(i) = bodyx(i)
obodyy(i) = bodyy(i)
bodyx(i) = bodyx(i) + bodyvx(i)
bodyy(i) = bodyy(i) + bodyvy(i)
NEXT
' clear/draw
q = (q + 1) MOD 16
FOR i = 1 TO bodies
COLOR 0
CIRCLE (obodyx(i), obodyy(i)), 4
COLOR 15
CIRCLE (bodyx(i), bodyy(i)), 4
'COLOR q
'LINE (bodyx(i), bodyy(i))-(bodyx(i) + bodyvx(i) * 30, bodyy(i) + bodyvy(i) * 30)
NEXT
COLOR 2
LINE (obodyx(1), obodyy(1))-(bodyx(1), bodyy(1))
'FOR i = 1 TO bodies - 1
' FOR j = i + 1 TO bodies
' COLOR 0
' LINE (obodyx(i), obodyy(i))-(obodyx(j), obodyy(j))
' COLOR 2
' LINE (bodyx(i), bodyy(i))-(bodyx(j), bodyy(j))
' NEXT
'NEXT
LOOP
;---------------------------------------------------------------------------
; start
;---------------------------------------------------------------------------
start
desc
msg "It's a room."
objects
start/key
start/door
start/key
id "key"
desc
msg "It's a key."
actions
use door
ifn start/door.flags.locked
msg "The door isn't locked."
if start/door.flags.locked
msg "The lock on the door goes 'click'."
set start/door.flags.locked false
examine
msg "It is shiny."
start/door
id "door"
desc
msg "You see a door."
flags
locked true
open false
actions
open
if start/door.flags.locked
msg "It is locked."
ifn start/door.flags.locked
msg "The door opens."
close
ifn start/door.flags.open
msg "It is already closed."
if start/door.flags.open
msg "The door closes."
go
if start/door.flags.open
goto end
ifn start/door.flags.open
msg "The door is closed."
examine
msg "It looks just like a door."
;---------------------------------------------------------------------------
; end
;---------------------------------------------------------------------------
end
desc
"Congratimafations! Another room."
objects
start/door
macroScript ExportCamera category:"Cameras" toolTip:"Blech!" Icon:#("Cameras",2)
(
filename = maxFileName
flen = findString filename ".max"
filename = substring filename 1 (flen-1)
sname = filename
filename = maxFilePath + filename + ".piper3d"
deletefile filename
out_file = createfile filename
format ";------------------------------------------------------------\n" to:out_file
format "; Piper 3D scene file\n" to:out_file
format ";\n" to:out_file
format "; Scene: % \n" sname to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_begin\n" sname to:out_file
format "\n" to:out_file
animend = animationRange.end as string
animend = substring animend 1 (findString animend "f"-1)
format " dc.w % ; no. frames\n" animend to:out_file
format " dc.w % ; no. objects\n" objects.count to:out_file
faces = 0
vertices = 0
for o in objects do (
if classOf o == Editable_Mesh then (
faces += o.numfaces
vertices += o.numverts
)
)
format " dc.w % ; no. vertices\n" vertices to:out_file
format " dc.w % ; no. faces\n" faces to:out_file
format "\n" to:out_file
format " dc.w 0 ; current frame\n" to:out_file
format "\n" to:out_file
format " dc.l %_vtx ; begin vertices\n" sname sname to:out_file
format " dc.l %_fcs ; begin fæces\n" sname sname to:out_file
format " dc.l %_mtx ; begin matrices\n" sname sname to:out_file
format " dc.l 0 ; begin vertex normals\n" to:out_file
format "\n" to:out_file
format " dc.w 0 ; init flag\n" to:out_file
format "\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "; Vertex groups\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_vtx\n" sname to:out_file
format "\n" to:out_file
for i=1 to objects.count do (
format "; group %: %\n" (i-1) objects[i].name to:out_file
format "\n" to:out_file
if classOf objects[i] == Editable_Mesh then (
obimat = (inverse objects[i].transform)
themesh = snapshotAsMesh objects[i]
format " dc.w % ; no. vertices\n" themesh.numverts to:out_file
for j=1 to themesh.numverts do (
v = (getVert themesh j) * obimat
vxs = formatf v.x 6
vys = formatf v.y 6
vzs = formatf v.z 6
format " dc.s %,%,%\n" vxs vys vzs to:out_file
)
) else (
format " dc.w 0 ; not a mesh\n" to:out_file
)
format "\n" to:out_file
)
format ";------------------------------------------------------------\n" to:out_file
format "; Fæces\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_fcs\n" sname to:out_file
format "\n" to:out_file
voff = 0
for i=1 to objects.count do (
format "; group %: %\n" (i-1) objects[i].name to:out_file
format "\n" to:out_file
if classOf objects[i] == Editable_Mesh then (
themesh = snapshotAsMesh objects[i]
for j=1 to themesh.numfaces do (
f = getFace themesh j
format " dc.w %,%,%\n" (int (f.x-1+voff)) (int (f.y-1+voff)) (int (f.z-1+voff)) to:out_file
smat = objects[i].material
mattype = "0"
u1 = 0
v1 = 0
u2 = 0
v2 = 0
u3 = 0
v3 = 0
if smat == undefined then (
matname = "0"
) else (
if getNumSubMtls smat == 0 then (
mat = smat
) else (
matid = getFaceMatID themesh j
mat = smat.MaterialList[matid]
)
matname = (int mat.diffuse.r)*256*256 + (int mat.diffuse.g)*256 + (int mat.diffuse.b)
dmap = mat.diffuseMap
if dmap != undefined then (
mattype = "1"
matname = dmap.filename
fntokens = filterString matname "\\"
matname = fntokens[fntokens.count]
fntokens = filterString matname "."
matname = fntokens[1]
fntokens = filterString matname "-"
matname = ""
for k=1 to fntokens.count do (
matname = matname + fntokens[k]
if k < fntokens.count then matname=matname+"m"
)
matname = sname + "_" + matname + "+1024+14"
tverts = getTVFace theMesh j
u1 = (int (getTVert theMesh tverts[1] * 65535).x)
v1 = 65535 - (int (getTVert theMesh tverts[1] * 65535).y)
u2 = (int (getTVert theMesh tverts[2] * 65535).x)
v2 = 65536 - (int (getTVert theMesh tverts[2] * 65535).y)
macroScript ExportCamera category:"Cameras" toolTip:"Blech!" Icon:#("Cameras",2)
(
filename = maxFileName
flen = findString filename ".max"
filename = substring filename 1 (flen-1)
sname = filename
filename = maxFilePath + filename + ".piper3d"
deletefile filename
out_file = createfile filename
format ";------------------------------------------------------------\n" to:out_file
format "; Piper 3D scene file\n" to:out_file
format ";\n" to:out_file
format "; Scene: % \n" sname to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_begin\n" sname to:out_file
format "\n" to:out_file
animend = animationRange.end as string
animend = substring animend 1 (findString animend "f"-1)
format " dc.w % ; no. frames\n" animend to:out_file
format " dc.w % ; no. objects\n" objects.count to:out_file
faces = 0
vertices = 0
for o in objects do (
if classOf o == Editable_Mesh then (
faces += o.numfaces
vertices += o.numverts
)
)
format " dc.w % ; no. vertices\n" vertices to:out_file
format " dc.w % ; no. faces\n" faces to:out_file
format "\n" to:out_file
format " dc.w 0 ; current frame\n" to:out_file
format "\n" to:out_file
format " dc.l %_vtx ; begin vertices\n" sname sname to:out_file
format " dc.l %_fcs ; begin fæces\n" sname sname to:out_file
format " dc.l %_mtx ; begin matrices\n" sname sname to:out_file
format " dc.l 0 ; begin vertex normals\n" to:out_file
format "\n" to:out_file
format " dc.w 0 ; init flag\n" to:out_file
format "\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "; Vertex groups\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_vtx\n" sname to:out_file
format "\n" to:out_file
for i=1 to objects.count do (
format "; group %: %\n" (i-1) objects[i].name to:out_file
format "\n" to:out_file
if classOf objects[i] == Editable_Mesh then (
obimat = (inverse objects[i].transform)
themesh = snapshotAsMesh objects[i]
format " dc.w % ; no. vertices\n" themesh.numverts to:out_file
for j=1 to themesh.numverts do (
v = (getVert themesh j) * obimat
vxs = formatf v.x 6
vys = formatf v.y 6
vzs = formatf v.z 6
format " dc.s %,%,%\n" vxs vys vzs to:out_file
)
) else (
format " dc.w 0 ; not a mesh\n" to:out_file
)
format "\n" to:out_file
)
format ";------------------------------------------------------------\n" to:out_file
format "; Fæces\n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_fcs\n" sname to:out_file
format "\n" to:out_file
voff = 0
for i=1 to objects.count do (
format "; group %: %\n" (i-1) objects[i].name to:out_file
format "\n" to:out_file
if classOf objects[i] == Editable_Mesh then (
themesh = snapshotAsMesh objects[i]
for j=1 to themesh.numfaces do (
f = getFace themesh j
format " dc.w %,%,%\n" (int (f.x-1+voff)) (int (f.y-1+voff)) (int (f.z-1+voff)) to:out_file
smat = objects[i].material
mattype = "0"
u1 = 0
v1 = 0
u2 = 0
v2 = 0
u3 = 0
v3 = 0
if smat == undefined then (
matname = "0"
) else (
if getNumSubMtls smat == 0 then (
mat = smat
) else (
matid = getFaceMatID themesh j
mat = smat.MaterialList[matid]
)
matname = (int mat.diffuse.r)*256*256 + (int mat.diffuse.g)*256 + (int mat.diffuse.b)
dmap = mat.diffuseMap
if dmap != undefined then (
mattype = "1"
matname = dmap.filename
fntokens = filterString matname "\\"
matname = fntokens[fntokens.count]
fntokens = filterString matname "."
matname = fntokens[1]
fntokens = filterString matname "-"
matname = ""
for k=1 to fntokens.count do (
matname = matname + fntokens[k]
if k < fntokens.count then matname=matname+"m"
)
matname = sname + "_" + matname + "+1024+14"
tverts = getTVFace theMesh j
u1 = (int (getTVert theMesh tverts[1] * 65535).x)
v1 = 65535 - (int (getTVert theMesh tverts[1] * 65535).y)
u2 = (int (getTVert theMesh tverts[2] * 65535).x)
v2 = 65536 - (int (getTVert theMesh tverts[2] * 65535).y)
u3 = (int (getTVert theMesh tverts[3] * 65535).x)
v3 = 65536 - (int (getTVert theMesh tverts[3] * 65535).y)
if u1 > 65535 then u1 = 65535
if v1 > 65535 then v1 = 65535
if u2 > 65535 then u2 = 65535
if v2 > 65535 then v2 = 65535
if u3 > 65535 then u3 = 65535
if v3 > 65535 then v3 = 65535
/*
if u1 < 0 then u1 = 0
if v1 < 0 then v1 = 0
if u2 < 0 then u2 = 0
if v2 < 0 then v2 = 0
if u3 < 0 then u3 = 0
if v3 < 0 then v3 = 0
*/
if mat.opacityMap != undefined then (
mattype = "2"
)
)
)
format " dc.w %\n" mattype to:out_file
format " dc.l %\n" matname to:out_file
format " dc.w %,%,%,%,%,%\n" u1 v1 u2 v2 u3 v3 to:out_file
)
format "\n" to:out_file
voff += themesh.numverts
)
)
format ";------------------------------------------------------------\n" to:out_file
format "; \n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_mtx\n" sname to:out_file
format "\n" to:out_file
for i = animationRange.start to animationRange.end do (
sliderTime=i
format "; index %\n" i to:out_file
format "\n" to:out_file
for j = 1 to objects.count do (
o=objects[j]
vpm=getViewTM()
tm=o.transform*vpm
tm1=tm.row1
tm2=tm.row2
tm3=tm.row3
tm4=tm.row4
tm11=formatf tm1.x 6
tm12=formatf tm1.y 6
tm13=formatf tm1.z 6
tm21=formatf tm2.x 6
tm22=formatf tm2.y 6
tm23=formatf tm2.z 6
tm31=formatf tm3.x 6
tm32=formatf tm3.y 6
tm33=formatf tm3.z 6
tm41=formatf tm4.x 6
tm42=formatf tm4.y 6
tm43=formatf tm4.z 6
format " dc.s %,%,%\n" tm11 tm12 tm13 to:out_file
format " dc.s %,%,%\n" tm21 tm22 tm23 to:out_file
format " dc.s %,%,%\n" tm31 tm32 tm33 to:out_file
format " dc.s %,%,%\n" tm41 tm42 tm43 to:out_file
format "\n" to:out_file
)
)
close out_file
shelllaunch "notepad.exe" filename
)
-- theend u3 = (int (getTVert theMesh tverts[3] * 65535).x)
v3 = 65536 - (int (getTVert theMesh tverts[3] * 65535).y)
if u1 > 65535 then u1 = 65535
if v1 > 65535 then v1 = 65535
if u2 > 65535 then u2 = 65535
if v2 > 65535 then v2 = 65535
if u3 > 65535 then u3 = 65535
if v3 > 65535 then v3 = 65535
/*
if u1 < 0 then u1 = 0
if v1 < 0 then v1 = 0
if u2 < 0 then u2 = 0
if v2 < 0 then v2 = 0
if u3 < 0 then u3 = 0
if v3 < 0 then v3 = 0
*/
if mat.opacityMap != undefined then (
mattype = "2"
)
)
)
format " dc.w %\n" mattype to:out_file
format " dc.l %\n" matname to:out_file
format " dc.w %,%,%,%,%,%\n" u1 v1 u2 v2 u3 v3 to:out_file
)
format "\n" to:out_file
voff += themesh.numverts
)
)
format ";------------------------------------------------------------\n" to:out_file
format "; \n" to:out_file
format ";------------------------------------------------------------\n" to:out_file
format "\n" to:out_file
format "%_mtx\n" sname to:out_file
format "\n" to:out_file
for i = animationRange.start to animationRange.end do (
sliderTime=i
format "; index %\n" i to:out_file
format "\n" to:out_file
for j = 1 to objects.count do (
o=objects[j]
vpm=getViewTM()
tm=o.transform*vpm
tm1=tm.row1
tm2=tm.row2
tm3=tm.row3
tm4=tm.row4
tm11=formatf tm1.x 6
tm12=formatf tm1.y 6
tm13=formatf tm1.z 6
tm21=formatf tm2.x 6
tm22=formatf tm2.y 6
tm23=formatf tm2.z 6
tm31=formatf tm3.x 6
tm32=formatf tm3.y 6
tm33=formatf tm3.z 6
tm41=formatf tm4.x 6
tm42=formatf tm4.y 6
tm43=formatf tm4.z 6
format " dc.s %,%,%\n" tm11 tm12 tm13 to:out_file
format " dc.s %,%,%\n" tm21 tm22 tm23 to:out_file
format " dc.s %,%,%\n" tm31 tm32 tm33 to:out_file
format " dc.s %,%,%\n" tm41 tm42 tm43 to:out_file
format "\n" to:out_file
)
)
close out_file
shelllaunch "notepad.exe" filename
)
-- theend
void DS3231::setDateTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second)
{
Wire.beginTransmission(DS3231_ADDRESS);
#if ARDUINO >= 100
Wire.write(DS3231_REG_TIME);
#else
Wire.send(DS3231_REG_TIME);
#endif
#if ARDUINO >= 100
Wire.write(dec2bcd(second));
Wire.write(dec2bcd(minute));
Wire.write(dec2bcd(hour));
Wire.write(dec2bcd(dow(year, month, day)));
Wire.write(dec2bcd(day));
Wire.write(dec2bcd(month));
Wire.write(dec2bcd(year-2000));
#else
Wire.send(dec2bcd(second));
Wire.send(dec2bcd(minute));
Wire.send(dec2bcd(hour));
Wire.send(dec2bcd(dow(year, month, day)));
Wire.send(dec2bcd(day));
Wire.send(dec2bcd(month));
Wire.send(dec2bcd(year-2000));
#endif
#if ARDUINO >= 100
Wire.write(DS3231_REG_TIME);
#else
Wire.send(DS3231_REG_TIME);
#endif
Wire.endTransmission();
}
void DS3231::setDateTime(uint32_t t)
{
t -= 946681200;
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
second = t % 60;
t /= 60;
minute = t % 60;
t /= 60;
hour = t % 24;
uint16_t days = t / 24;
uint8_t leap;
for (year = 0; ; ++year)
{
leap = year % 4 == 0;
if (days < 365 + leap)
{
break;
}
days -= 365 + leap;
}
for (month = 1; ; ++month)
{
uint8_t daysPerMonth = pgm_read_byte(daysArray + month - 1);
if (leap && month == 2)
{
++daysPerMonth;
}
if (days < daysPerMonth)
{
break;
}
days -= daysPerMonth;
}
day = days + 1;
setDateTime(year+2000, month, day, hour, minute, second);
}
void DS3231::setDateTime(const char* date, const char* time)
{
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
year = conv2d(date + 9);
switch (date[0])
{
case 'J': month = date[1] == 'a' ? 1 : month = date[2] == 'n' ? 6 : 7; break;
case 'F': month = 2; break;
case 'A': month = date[2] == 'r' ? 4 : 8; break;
case 'M': month = date[2] == 'r' ? 3 : 5; break;
case 'S': month = 9; break;
case 'O': month = 10; break;
case 'N': month = 11; break;
case 'D': month = 12; break;
}
day = conv2d(date + 4);
hour = conv2d(time);
minute = conv2d(time + 3);
second = conv2d(time + 6);
setDateTime(year+2000, month, day, hour, minute, second);
}
char* DS3231::dateFormat(const char* dateFormat, RTCDateTime dt)
{
char buffer[255];
buffer[0] = 0;
char helper[11];
while (*dateFormat != '\0')
{
switch (dateFormat[0])
{
// Day decoder
case 'd':
sprintf(helper, "%02d", dt.day);
strcat(buffer, (const char *)helper);
break;
case 'j':
sprintf(helper, "%d", dt.day);
strcat(buffer, (const char *)helper);
break;
case 'l':
strcat(buffer, (const char *)strDayOfWeek(dt.dayOfWeek));
break;
case 'D':
strncat(buffer, strDayOfWeek(dt.dayOfWeek), 3);
break;
case 'N':
sprintf(helper, "%d", dt.dayOfWeek);
strcat(buffer, (const char *)helper);
break;
case 'w':
sprintf(helper, "%d", (dt.dayOfWeek + 7) % 7);
strcat(buffer, (const char *)helper);
break;
case 'z':
sprintf(helper, "%d", dayInYear(dt.year, dt.month, dt.day)+1);
strcat(buffer, (const char *)helper);
break;
case 'S':
strcat(buffer, (const char *)strDaySufix(dt.day));
break;
// Month decoder
case 'm':
sprintf(helper, "%02d", dt.month);
strcat(buffer, (const char *)helper);
break;
case 'n':
sprintf(helper, "%d", dt.month);
strcat(buffer, (const char *)helper);
break;
case 'F':
strcat(buffer, (const char *)strMonth(dt.month));
break;
case 'M':
strncat(buffer, (const char *)strMonth(dt.month), 3);
break;
case 't':
sprintf(helper, "%d", daysInMonth(dt.year, dt.month));
strcat(buffer, (const char *)helper);
break;
// Year decoder
case 'Y':
sprintf(helper, "%d", dt.year);
strcat(buffer, (const char *)helper);
break;
case 'y': sprintf(helper, "%02d", dt.year-2000);
strcat(buffer, (const char *)helper);
break;
case 'L':
sprintf(helper, "%d", isLeapYear(dt.year));
strcat(buffer, (const char *)helper);
break;
// Hour decoder
case 'H':
sprintf(helper, "%02d", dt.hour);
strcat(buffer, (const char *)helper);
break;
case 'G':
sprintf(helper, "%d", dt.hour);
strcat(buffer, (const char *)helper);
break;
case 'h':
sprintf(helper, "%02d", hour12(dt.hour));
strcat(buffer, (const char *)helper);
break;
case 'g':
sprintf(helper, "%d", hour12(dt.hour));
strcat(buffer, (const char *)helper);
break;
case 'A':
strcat(buffer, (const char *)strAmPm(dt.hour, true));
break;
case 'a':
strcat(buffer, (const char *)strAmPm(dt.hour, false));
break;
// Minute decoder
case 'i':
sprintf(helper, "%02d", dt.minute);
strcat(buffer, (const char *)helper);
break;
// Second decoder
case 's':
sprintf(helper, "%02d", dt.second);
strcat(buffer, (const char *)helper);
break;
// Misc decoder
case 'U':
sprintf(helper, "%lu", dt.unixtime);
strcat(buffer, (const char *)helper);
break;
default:
strncat(buffer, dateFormat, 1);
break;
}
dateFormat++;
}
return buffer;
}
char* DS3231::dateFormat(const char* dateFormat, RTCAlarmTime dt)
{
char buffer[255];
buffer[0] = 0;
char helper[11];
while (*dateFormat != '\0')
{
switch (dateFormat[0])
{
// Day decoder
case 'd':
sprintf(helper, "%02d", dt.day);
strcat(buffer, (const char *)helper);
break;
case 'j':
sprintf(helper, "%d", dt.day);
strcat(buffer, (const char *)helper);
break;
case 'l':
strcat(buffer, (const char *)strDayOfWeek(dt.day));
break;
case 'D':
strncat(buffer, strDayOfWeek(dt.day), 3);
break;
case 'N':
sprintf(helper, "%d", dt.day);
strcat(buffer, (const char *)helper);
break;
case 'w':
sprintf(helper, "%d", (dt.day + 7) % 7);
strcat(buffer, (const char *)helper);
break;
case 'S':
strcat(buffer, (const char *)strDaySufix(dt.day));
break;
// Hour decoder
case 'H':
sprintf(helper, "%02d", dt.hour);
strcat(buffer, (const char *)helper);
break;
case 'G':
sprintf(helper, "%d", dt.hour);
strcat(buffer, (const char *)helper);
break;
case 'h':
sprintf(helper, "%02d", hour12(dt.hour));
strcat(buffer, (const char *)helper);
break;
case 'g':
sprintf(helper, "%d", hour12(dt.hour));
strcat(buffer, (const char *)helper);
break;
case 'A':
strcat(buffer, (const char *)strAmPm(dt.hour, true));
break;
case 'a':
strcat(buffer, (const char *)strAmPm(dt.hour, false));
break;
// Minute decoder
case 'i':
sprintf(helper, "%02d", dt.minute);
strcat(buffer, (const char *)helper);
break;
// Second decoder
case 's':
sprintf(helper, "%02d", dt.second);
strcat(buffer, (const char *)helper);
break;
default:
strncat(buffer, dateFormat, 1);
break;
}
dateFormat++;
}
return buffer;
}
RTCDateTime DS3231::getDateTime(void)
{
int values[7];
Wire.beginTransmission(DS3231_ADDRESS);
#if ARDUINO >= 100
Wire.write(DS3231_REG_TIME);
#else
Wire.send(DS3231_REG_TIME);
#endif
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
while(!Wire.available()) {};
for (int i = 6; i >= 0; i--)
{
#if ARDUINO >= 100
values[i] = bcd2dec(Wire.read());
#else
values[i] = bcd2dec(Wire.receive());
#endif
}
Wire.endTransmission();
t.year = values[0] + 2000;
t.month = values[1];
t.day = values[2];
t.dayOfWeek = values[3];
t.hour = values[4];
t.minute = values[5];
t.second = values[6];
t.unixtime = unixtime();
return t;
}
uint8_t DS3231::isReady(void)
{
return true;
}
void DS3231::enableOutput(bool enabled)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b11111011;
value |= (!enabled << 2);
writeRegister8(DS3231_REG_CONTROL, value);
}
void DS3231::setBattery(bool timeBattery, bool squareBattery)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
if (squareBattery)
{
value |= 0b01000000;
} else
{
value &= 0b10111111;
}
if (timeBattery)
{
value &= 0b01111011;
} else
{
value |= 0b10000000;
}
writeRegister8(DS3231_REG_CONTROL, value);
}
bool DS3231::isOutput(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b00000100;
value >>= 2;
return !value;
}
void DS3231::setOutput(DS3231_sqw_t mode)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b11100111;
value |= (mode << 3);
writeRegister8(DS3231_REG_CONTROL, value);
}
DS3231_sqw_t DS3231::getOutput(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b00011000;
value >>= 3;
return (DS3231_sqw_t)value;
}
void DS3231::enable32kHz(bool enabled)
{
uint8_t value;
value = readRegister8(DS3231_REG_STATUS);
value &= 0b11110111;
value |= (enabled << 3);
writeRegister8(DS3231_REG_STATUS, value);
}
bool DS3231::is32kHz(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_STATUS);
value &= 0b00001000;
value >>= 3;
return value;
}
#ifndef DS3231_h
#define DS3231_h
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#define DS3231_ADDRESS (0x68)
#define DS3231_REG_TIME (0x00)
#define DS3231_REG_ALARM_1 (0x07)
#define DS3231_REG_ALARM_2 (0x0B)
#define DS3231_REG_CONTROL (0x0E)
#define DS3231_REG_STATUS (0x0F)
#define DS3231_REG_TEMPERATURE (0x11)
#ifndef RTCDATETIME_STRUCT_H
#define RTCDATETIME_STRUCT_H
struct RTCDateTime
{
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t dayOfWeek;
uint32_t unixtime;
};
struct RTCAlarmTime
{
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
};
#endif
typedef enum
{
DS3231_1HZ = 0x00,
DS3231_4096HZ = 0x01,
DS3231_8192HZ = 0x02,
DS3231_32768HZ = 0x03
} DS3231_sqw_t;
typedef enum
{
DS3231_EVERY_SECOND = 0b00001111,
DS3231_MATCH_S = 0b00001110,
DS3231_MATCH_M_S = 0b00001100,
DS3231_MATCH_H_M_S = 0b00001000,
DS3231_MATCH_DT_H_M_S = 0b00000000,
DS3231_MATCH_DY_H_M_S = 0b00010000
} DS3231_alarm1_t;
typedef enum
{
DS3231_EVERY_MINUTE = 0b00001110,
DS3231_MATCH_M = 0b00001100,
DS3231_MATCH_H_M = 0b00001000,
DS3231_MATCH_DT_H_M = 0b00000000,
DS3231_MATCH_DY_H_M = 0b00010000
} DS3231_alarm2_t;
class DS3231
{
public:
bool begin(void);
void setDateTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
void setDateTime(uint32_t t);
void setDateTime(const char* date, const char* time);
RTCDateTime getDateTime(void);
uint8_t isReady(void);
DS3231_sqw_t getOutput(void);
void setOutput(DS3231_sqw_t mode);
void enableOutput(bool enabled);
bool isOutput(void);
void enable32kHz(bool enabled);
bool is32kHz(void);
void forceConversion(void);
float readTemperature(void);
void setAlarm1(uint8_t dydw, uint8_t hour, uint8_t minute, uint8_t second, DS3231_alarm1_t mode, bool armed = true);
RTCAlarmTime getAlarm1(void);
DS3231_alarm1_t getAlarmType1(void);
bool isAlarm1(bool clear = true);
void armAlarm1(bool armed);
bool isArmed1(void);
void clearAlarm1(void);
void setAlarm2(uint8_t dydw, uint8_t hour, uint8_t minute, DS3231_alarm2_t mode, bool armed = true);
RTCAlarmTime getAlarm2(void);
DS3231_alarm2_t getAlarmType2(void);
bool isAlarm2(bool clear = true);
void armAlarm2(bool armed);
bool isArmed2(void);
void clearAlarm2(void);
void setBattery(bool timeBattery, bool squareBattery);
char* dateFormat(const char* dateFormat, RTCDateTime dt);
char* dateFormat(const char* dateFormat, RTCAlarmTime dt);
private:
RTCDateTime t;
char *strDayOfWeek(uint8_t dayOfWeek);
char *strMonth(uint8_t month);
char *strAmPm(uint8_t hour, bool uppercase);
char *strDaySufix(uint8_t day);
uint8_t hour12(uint8_t hour24);
uint8_t bcd2dec(uint8_t bcd);
uint8_t dec2bcd(uint8_t dec);
long time2long(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds);
uint16_t date2days(uint16_t year, uint8_t month, uint8_t day);
uint8_t daysInMonth(uint16_t year, uint8_t month);
uint16_t dayInYear(uint16_t year, uint8_t month, uint8_t day);
bool isLeapYear(uint16_t year);
uint8_t dow(uint16_t y, uint8_t m, uint8_t d);
uint32_t unixtime(void);
uint8_t conv2d(const char* p);
void writeRegister8(uint8_t reg, uint8_t value);
uint8_t readRegister8(uint8_t reg);
};
#endif
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iostream>
#include <runner.cuh>
#include <vector>
#define cudaCheck(err) (cudaCheck(err, __FILE__, __LINE__))
const std::string errLogFile = "matrixValidationFailure.txt";
int main(int argc, char **argv) {
if (argc != 2) {
std::cerr << "Please select a kernel (range 0 - 12, 0 for NVIDIA cuBLAS)"
<< std::endl;
exit(EXIT_FAILURE);
}
// get kernel number
int kernel_num = std::stoi(argv[1]);
if (kernel_num < 0 || kernel_num > 12) {
std::cerr << "Please enter a valid kernel number (0-12)" << std::endl;
exit(EXIT_FAILURE);
}
// get environment variable for device
int deviceIdx = 0;
if (getenv("DEVICE") != NULL) {
deviceIdx = atoi(getenv("DEVICE"));
}
cudaCheck(cudaSetDevice(deviceIdx));
printf("Running kernel %d on device %d.\n", kernel_num, deviceIdx);
// print some device info
// CudaDeviceInfo();
// Declare the handle, create the handle, cublasCreate will return a value of
// type cublasStatus_t to determine whether the handle was created
// successfully (the value is 0)
cublasHandle_t handle;
if (cublasCreate(&handle)) {
std::cerr << "Create cublas handle error." << std::endl;
exit(EXIT_FAILURE);
};
// Using cudaEvent for gpu stream timing, cudaEvent is equivalent to
// publishing event tasks in the target stream
float elapsed_time;
cudaEvent_t beg, end;
cudaEventCreate(&beg);
cudaEventCreate(&end);
// cuBLAS FLOPs ceiling is reached at 8192
std::vector<int> SIZE = {128, 256, 512, 1024, 2048, 4096};
long m, n, k, max_size;
max_size = SIZE[SIZE.size() - 1];
std::cout << "Max size: " << max_size << std::endl;
float alpha = 0.5, beta = 3.0; // GEMM input parameters, C=α*AB+β*C
float *A = nullptr, *B = nullptr, *C = nullptr,
*C_ref = nullptr; // host matrices
float *dA = nullptr, *dB = nullptr, *dC = nullptr,
*dC_ref = nullptr; // device matrices
A = (float *)malloc(sizeof(float) * max_size * max_size);
B = (float *)malloc(sizeof(float) * max_size * max_size);
C = (float *)malloc(sizeof(float) * max_size * max_size);
C_ref = (float *)malloc(sizeof(float) * max_size * max_size);
randomize_matrix(A, max_size * max_size);
randomize_matrix(B, max_size * max_size);
randomize_matrix(C, max_size * max_size);
cudaCheck(cudaMalloc((void **)&dA, sizeof(float) * max_size * max_size));
cudaCheck(cudaMalloc((void **)&dB, sizeof(float) * max_size * max_size));
cudaCheck(cudaMalloc((void **)&dC, sizeof(float) * max_size * max_size));
cudaCheck(cudaMalloc((void **)&dC_ref, sizeof(float) * max_size * max_size));
cudaCheck(cudaMemcpy(dA, A, sizeof(float) * max_size * max_size,
cudaMemcpyHostToDevice));
cudaCheck(cudaMemcpy(dB, B, sizeof(float) * max_size * max_size,
cudaMemcpyHostToDevice));
cudaCheck(cudaMemcpy(dC, C, sizeof(float) * max_size * max_size,
cudaMemcpyHostToDevice));
cudaCheck(cudaMemcpy(dC_ref, C, sizeof(float) * max_size * max_size,
cudaMemcpyHostToDevice));
int repeat_times = 50;
for (int size : SIZE) {
m = 32;
n = k = size;
std::cout << "dimensions(m,n,k) " << m << "," << n << "," << k << ", alpha: " << alpha
<< ", beta: " << beta << std::endl;
// Verify the correctness of the calculation, and execute it once before the
// kernel function timing to avoid cold start errors
if (kernel_num != 0) {
run_kernel(0, m, n, k, alpha, dA, dB, beta, dC_ref,
handle); // cuBLAS
run_kernel(kernel_num, m, n, k, alpha, dA, dB, beta, dC,
handle); // Executes the kernel, modifies the result matrix
cudaCheck(cudaDeviceSynchronize());
cudaCheck(cudaGetLastError()); // Check for async errors during kernel run
cudaMemcpy(C, dC, sizeof(float) * m * n, cudaMemcpyDeviceToHost);
cudaMemcpy(C_ref, dC_ref, sizeof(float) * m * n, cudaMemcpyDeviceToHost);
if (!verify_matrix(C_ref, C, m * n)) {
std::cout
<< "Failed to pass the correctness verification against NVIDIA "
"cuBLAS."
<< std::endl;
if (m <= 128) {
std::cout << " Logging faulty output into " << errLogFile << "\n";
std::ofstream fs;
fs.open(errLogFile);
fs << "A:\n";
print_matrix(A, m, n, fs);
fs << "B:\n";
print_matrix(B, m, n, fs);
fs << "C:\n";
print_matrix(C, m, n, fs);
fs << "Should:\n";
print_matrix(C_ref, m, n, fs);
}
exit(EXIT_FAILURE);
}
}
cudaEventRecord(beg);
for (int j = 0; j < repeat_times; j++) {
// We don't reset dC between runs to save time
run_kernel(kernel_num, m, n, k, alpha, dA, dB, beta, dC, handle);
}
cudaEventRecord(end);
cudaEventSynchronize(beg);
cudaEventSynchronize(end);
cudaEventElapsedTime(&elapsed_time, beg, end);
elapsed_time /= 1000.; // Convert to seconds
long flops = 2 * m * n * k;
printf(
"Average elapsed time: (%7.6f) s, performance: (%7.1f) GFLOPS. size: "
"(%ld).\n",
elapsed_time / repeat_times,
(repeat_times * flops * 1e-9) / elapsed_time, m);
fflush(stdout);
// make dC and dC_ref equal again (we modified dC while calling our kernel
// for benchmarking)
cudaCheck(cudaMemcpy(dC, dC_ref, sizeof(float) * m * n,
cudaMemcpyDeviceToDevice));
}
// Free up CPU and GPU space
free(A);
free(B);
free(C);
free(C_ref);
cudaFree(dA);
cudaFree(dB);
cudaFree(dC);
cudaFree(dC_ref);
cublasDestroy(handle);
return 0;
};
#include <cuda_runtime.h>
#include <iostream>
#include <vector>
__global__ void kernel(uint *A, uint *B, int row) {
auto x = threadIdx.x / 4;
auto y = threadIdx.x % 4;
A[x * row + y] = x;
B[x * row + y] = y;
}
int main(int argc, char **argv) {
uint *Xs, *Ys;
uint *Xs_d, *Ys_d;
uint SIZE = 4;
Xs = (uint *)malloc(SIZE * SIZE * sizeof(uint));
Ys = (uint *)malloc(SIZE * SIZE * sizeof(uint));
cudaMalloc((void **)&Xs_d, SIZE * SIZE * sizeof(uint));
cudaMalloc((void **)&Ys_d, SIZE * SIZE * sizeof(uint));
dim3 grid_size(1, 1, 1);
dim3 block_size(4 * 4);
kernel<<<grid_size, block_size>>>(Xs_d, Ys_d, 4);
cudaMemcpy(Xs, Xs_d, SIZE * SIZE * sizeof(uint), cudaMemcpyDeviceToHost);
cudaMemcpy(Ys, Ys_d, SIZE * SIZE * sizeof(uint), cudaMemcpyDeviceToHost);
cudaDeviceSynchronize();
for (int row = 0; row < SIZE; ++row) {
for (int col = 0; col < SIZE; ++col) {
std::cout << "[" << Xs[row * SIZE + col] << "|" << Ys[row * SIZE + col]
<< "] ";
}
std::cout << "\n";
}
cudaFree(Xs_d);
cudaFree(Ys_d);
free(Xs);
free(Ys);
}
name: SGEMM_CUDA
channels:
- conda-forge
dependencies:
- python
- black
- cmake
- matplotlib
- seaborn
- tabulate
.PHONY: all build debug clean profile bench cuobjdump
CMAKE := cmake
BUILD_DIR := build
BENCHMARK_DIR := benchmark_results
all: build
build:
@mkdir -p $(BUILD_DIR)
@cd $(BUILD_DIR) && $(CMAKE) -DCMAKE_BUILD_TYPE=Release ..
@$(MAKE) -C $(BUILD_DIR)
debug:
@mkdir -p $(BUILD_DIR)
@cd $(BUILD_DIR) && $(CMAKE) -DCMAKE_BUILD_TYPE=Debug ..
@$(MAKE) -C $(BUILD_DIR)
clean:
@rm -rf $(BUILD_DIR)
FUNCTION := $$(cuobjdump -symbols build/sgemm | grep -i Warptiling | awk '{print $$NF}')
cuobjdump: build
@cuobjdump -arch sm_86 -sass -fun $(FUNCTION) build/sgemm | c++filt > build/cuobjdump.sass
@cuobjdump -arch sm_86 -ptx -fun $(FUNCTION) build/sgemm | c++filt > build/cuobjdump.ptx
# Usage: make profile KERNEL=<integer> PREFIX=<optional string>
profile: build
@ncu --set full --export $(BENCHMARK_DIR)/$(PREFIX)kernel_$(KERNEL) --force-overwrite $(BUILD_DIR)/sgemm $(KERNEL)
bench: build
@bash gen_benchmark_results.sh
[-0.01, 3.00, 3.01, -2.04, -1.02, -3.02, 0.02, 0.02, 4.02, 4.03, -3.01, -3.04, 0.02, 4.01, 4.02, -4.01, -3.03, 1.01, -4.00, -1.04, -0.02, 3.03, -0.03, -1.04, 3.04, 2.03, 3.03, -1.04, -3.01, -3.04, 4.01, -2.01, 3.02, 2.03, -3.03, 1.00, 0.03, -1.01, -2.00, 4.03, -3.04, 2.02, 1.00, -3.04, 2.02, 2.03, 0.00, -4.02, -3.01, -4.02, -2.03, 1.00, 1.03, -3.01, -2.03, 0.00, 3.03, -4.02, 1.02, -1.02, 4.01, 1.02, 3.00, 1.03, 4.01, -0.03, 1.03, -2.02, -1.01, 2.02, -3.01, -0.04, 4.02, 2.04, -3.03, -2.00, 2.01, 4.04, 1.02, -0.01, 3.00, -2.02, -3.04, 1.03, -3.01, 3.03, -2.03, -4.02, 0.03, 0.00, -4.03, -4.00, -1.00, 2.02, 3.02, -4.01, -0.00, 0.01, 1.03, 4.03, 4.00, -0.04, 4.02, -2.04, 0.02, -2.03, 0.04, -2.01, 2.03, -3.02, 4.03, 3.04, 3.00, -1.03, -0.03, -4.03, -4.00, 4.02, 2.02, -4.00, -4.04, 4.04, -0.00, 1.01, -3.03, -0.03, 1.04, -2.01, -0.00, 3.04, 1.03, 2.04, 4.04, -1.02, 2.03, 0.03, 1.01, -4.04, 1.01, -1.02, -2.03, 3.00, 0.04, -0.00, -0.04, -1.04, 0.02, 3.01, -4.03, 0.01, 3.03, 0.01, 1.03, 3.00, -3.00, 1.04, 0.04, -2.04, -1.00, 0.02, 0.01, -2.01, -4.02, 4.02, -2.01, 2.04, -1.01, 2.03, 2.01, 0.02, 1.02, 4.01, 2.00, 1.02, 3.04, -1.01, -2.04, 3.02, 1.01, 0.04, 1.00, -3.04, 3.03, -2.00, 3.00, -3.01, 4.01, 3.01, 1.02, 0.02, 3.00, -1.00, 4.03, -0.02, 1.03, 1.01, 4.02, 4.02, 1.01, 0.01, 4.04, 2.02, 4.01, 4.04, -1.02, 3.03, 4.04, 3.04, -1.00, -1.02, -3.02, 2.01, -0.02, -1.01, 4.02, 0.03, 4.04, -2.03, -2.04, -2.02, -4.00, -3.03, -0.00, -0.03, 4.02, 2.04, -3.00, 2.04, -1.02, 0.01, -0.00, 3.04, -4.01, -2.01, 2.02, -4.01, 3.01, -2.03, 4.04, 3.01, -4.02, -2.00, -4.01, 3.03, -0.01, 2.02, -4.00, 3.03, 1.04, 2.02, -3.03, 2.01, 2.02, -0.02, -4.02, -2.00;
-1.04, -1.04, -2.00, -0.04, -1.00, -0.04, 0.04, -2.04, -2.04, -2.01, 2.00, 1.01, -4.03, 4.00, -0.02, -3.02, 1.04, -4.01, -1.00, -1.04, 4.03, -2.00, 3.04, -2.00, 1.00, 1.01, 1.02, -2.04, 1.00, 2.03, 0.03, 1.02, 3.00, -3.03, 0.01, -0.04, -3.03, -1.00, 3.03, -2.03, 0.03, 2.02, -4.00, -0.00, 3.00, 2.02, -3.03, -2.04, -2.04, -3.01, 1.04, -2.01, -2.01, 0.03, 1.04, 4.03, 2.01, 0.01, 4.03, 0.03, -4.04, -4.03, -4.00, -0.03, -0.01, 4.00, -2.00, 2.00, 3.01, 0.01, -4.00, -2.02, 2.01, 1.03, -4.03, -1.04, -3.02, 2.01, 3.01, 0.01, -1.01, -1.03, -3.02, -4.04, 2.03, 1.02, 1.02, -0.01, -2.02, 4.02, -4.03, -1.01, 1.00, -3.01, -4.01, 4.02, 2.03, 2.01, -0.03, -4.04, 1.00, -3.02, -2.03, 0.03, -3.03, -1.04, -3.01, -2.00, -3.02, -1.01, -2.02, 0.02, -2.01, 4.02, -2.00, -3.01, 4.04, 3.01, 1.02, -2.03, -2.02, -2.02, 2.02, 4.01, 2.00, -3.03, -1.04, -4.03, 0.01, -0.03, -3.00, 4.00, -4.02, -0.01, 4.01, -2.04, 1.03, -3.02, -4.00, -2.00, 4.04, -0.03, 3.02, -1.02, -1.03, -2.01, -0.04, -0.02, 3.02, 0.04, -0.03, 2.00, 0.04, 4.02, -4.03, -0.02, -1.00, -4.00, -2.01, -3.01, 2.01, -4.03, 4.00, 0.02, -1.01, 1.04, 3.00, -0.01, -1.04, 4.04, -3.01, 1.03, 2.02, 1.04, -2.01, -1.04, -2.02, -4.04, -0.00, -0.01, -0.00, -1.01, 0.03, 2.02, 1.04, -4.00, -0.04, 2.03, -2.03, -1.00, -1.02, -3.03, -0.01, -1.03, -2.02, 3.03, -1.03, -3.00, -2.02, 1.00, 0.02, 0.00, 2.01, 0.02, -1.01, -4.02, -1.03, 0.01, -3.00, -3.02, 3.04, -3.04, 0.04, -4.04, -4.02, 1.01, -1.00, -2.02, -3.02, -3.00, -4.01, 2.04, 3.01, 4.01, 2.00, 2.02, 1.00, -3.04, -0.04, -0.03, 2.02, 0.02, -3.00, 4.01, -2.04, 4.03, 2.04, -0.04, -3.00, 0.00, -3.00, -2.00, -3.03, 0.00, 3.04, -3.03, -1.02, -1.02, -0.00, 1.03, 0.01, 2.01, -4.01, -0.01, 4.01, 4.04;
2.02, -3.03, 2.01, -3.02, -2.03, -0.02, -1.01, 3.03, 1.04, -4.00, 2.04, -0.03, 1.00, 4.01, 2.03, -4.00, -2.04, 0.04, 2.00, -4.01, 0.04, -4.01, -1.04, 1.00, 0.02, 0.04, -3.03, -3.03, -1.02, -3.04, 0.04, 4.03, 3.01, 3.04, -0.02, -1.02, 1.02, -3.01, 3.04, 3.02, 2.04, 0.04, -2.02, -3.02, -1.03, 4.01, -1.02, 1.02, -2.00, 0.00, -2.03, -0.03, -2.00, 1.00, -1.04, -0.03, 1.02, -4.03, -1.02, -1.04, -1.03, -0.04, 3.01, 2.04, 2.02, -2.02, -3.03, 1.00, 1.01, -3.04, -3.02, 3.02, 4.02, -1.00, 0.02, 0.00, -1.00, -2.02, -3.00, 3.01, 3.04, 2.02, -4.02, -3.00, 4.02, 2.02, 2.00, -3.04, 4.04, -1.03, -0.01, 1.03, 1.00, 4.00, 2.04, 3.03, -2.01, 0.01, -2.01, 2.04, 0.01, -0.02, -4.01, 0.00, 0.03, -2.03, 1.00, 4.03, -2.02, 0.01, 0.04, -1.04, 1.00, 2.02, -4.02, -3.04, -0.00, 0.01, -3.04, 1.04, -0.01, 0.03, -0.01, 1.00, -0.00, 1.00, -3.02, -0.04, -4.02, 0.03, -3.00, -0.01, 3.01, -3.00, -3.00, 2.03, -0.01, 0.03, 0.02, -0.03, -2.03, -3.04, 4.04, -3.03, 2.03, -4.01, 2.01, 3.02, -2.04, 1.01, -4.03, 4.01, -0.02, 2.02, -4.02, 3.03, -3.00, 0.00, 0.00, -4.01, 4.02, 4.01, 3.01, 1.01, 0.00, 2.00, 0.04, -1.01, 0.01, -4.02, -0.03, -0.02, 3.00, -2.04, 2.04, -1.01, 3.01, -0.02, 2.04, -4.04, -1.04, -1.01, -0.01, 0.04, 0.03, 0.00, 0.00, 2.00, -4.04, -0.00, -0.02, 3.00, 1.00, 2.02, 1.02, -2.02, -3.00, -3.02, 2.03, 0.00, 0.00, -4.01, -4.04, 3.03, -4.00, 1.02, -4.00, -3.03, -0.00, -1.03, 4.03, -0.02, -3.03, 1.02, 1.03, -4.04, 1.04, 3.04, -4.04, -3.02, 0.04, -3.01, 0.04, 0.02, -1.04, 1.03, 1.04, 1.04, 3.03, 1.03, -4.04, 0.04, 3.04, 2.02, -2.03, 4.04, -0.00, -4.03, -3.02, -4.00, -4.02, 1.02, -1.03, 0.00, -3.02, -1.04, 3.04, 2.00, 4.04, -0.00, -4.04, 4.02, 3.03, 3.00, 1.00, 1.01;
3.02, -1.04, 2.00, 4.00, -1.01, 1.00, -0.00, 2.01, -4.04, -2.02, -0.01, -3.04, 4.03, -4.02, -1.00, -2.01, -0.01, 3.00, 3.01, -4.04, -3.01, -4.01, -1.01, -1.00, 1.02, -3.01, 2.04, -1.04, 4.03, -2.04, 3.02, 4.01, -2.02, -0.00, -0.04, 3.02, -2.01, -4.02, -2.03, 2.03, -2.03, -4.03, -4.02, 3.03, 4.00, -2.03, 4.00, 2.02, -4.04, 0.03, 1.03, -2.02, 0.03, -1.01, -1.02, 0.04, -3.00, 2.02, 0.02, 4.04, -3.02, -1.04, 0.02, -0.00, 0.01, -3.03, 4.01, 2.00, 3.00, -3.02, 0.00, -4.03, -1.04, -2.01, -0.02, -1.02, 4.01, 2.00, 4.03, 1.03, 1.04, 4.03, 4.01, 2.03, 1.04, -2.02, -2.01, 4.00, -0.02, 0.03, 2.04, -1.01, 4.00, -1.04, 2.02, -1.00, -3.02, 2.01, 2.03, -1.00, -0.04, -3.01, -3.00, 2.04, -2.03, 1.04, -0.04, 2.02, -4.04, 4.00, -1.02, -0.02, 3.00, -0.03, 2.00, 3.04, -4.04, 2.01, -0.02, 2.01, -2.03, 1.00, 3.01, 0.01, -2.00, 3.00, 1.04, 4.01, -0.02, 4.01, 3.03, 4.01, 2.04, -3.00, -2.04, -2.04, -2.01, 4.02, 3.02, 0.04, -4.04, 2.00, 1.02, -3.03, 2.00, 3.04, 4.04, 0.00, 3.03, 1.01, 4.00, -0.04, 2.03, 3.01, -2.03, 4.01, 3.01, 3.01, 0.01, 4.03, 4.04, -3.04, 4.01, -0.02, -4.04, -3.00, 1.04, -3.02, -2.00, 1.04, 2.00, -2.03, -2.03, -2.00, -2.02, -4.00, 0.01, 2.01, 0.00, -4.01, -4.03, 3.03, 3.02, -2.00, 3.04, 3.03, -1.00, -2.02, 3.02, -1.02, -3.03, 1.03, -4.03, -2.01, 0.04, -1.00, -1.01, 0.00, -4.01, -4.02, 2.03, 3.04, -0.00, -4.02, -3.04, -3.00, 1.04, -4.04, -0.03, 1.04, 0.01, 3.02, 0.04, 3.00, 2.03, -3.03, -3.04, -2.00, -3.03, 0.04, -3.01, 3.04, 0.02, 3.00, -4.03, -0.03, -4.01, 1.00, -3.03, -2.00, 3.04, -0.04, 1.01, 3.04, -0.04, -2.01, -2.00, -1.02, 3.02, -2.04, -3.04, -3.02, -1.03, -2.04, 0.04, 3.02, 1.01, 3.00, 3.03, -2.02, -3.00, 0.00, 3.02, 2.01, 1.03, 4.03;
cmake_minimum_required(VERSION 3.19)
project(NVIDIA_SGEMM_PRACTICE LANGUAGES CXX CUDA)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
find_package(CUDA REQUIRED)
# ensure cuda is available
include(CheckLanguage)
check_language(CUDA)
set(CMAKE_CXX_STANDARD 20)
set(CUDA_COMPUTE_CAPABILITY 86)
# in debug mode, add debug symbols to device code
# this disables most optimizations and kills performance
add_compile_options("$<$<AND:$<CONFIG:Debug>,$<COMPILE_LANGUAGE:CUDA>>:-G;-src-in-ptx>")
# add_compile_options("--ptxas-options=-v")
# Configure header file search paths
include_directories(${CUDA_INCLUDE_DIRS})
include_directories(${PROJECT_SOURCE_DIR}/src)
# Configure the source file path to be compiled
aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)
# generate executable
add_executable(sgemm sgemm.cu ${SRC})
set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
target_link_libraries(sgemm ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES})
add_executable(cuBLAS_sgemm cuBLAS_sgemm.cu )
set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
target_link_libraries(cuBLAS_sgemm ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES})
add_executable(simplest_kernel simplest_kernel.cu)
set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
target_link_libraries(simplest_kernel ${CUDA_LIBRARIES})
import gzip
import random
import tqdm
import numpy as np
import torch
from torch.optim import Adam
from torch.nn import functional as F
from torch.utils.data import DataLoader, Dataset
from simple_hierarchical_transformer import HierarchicalTransformer
# constants
NUM_BATCHES = int(1e5)
BATCH_SIZE = 2
GRADIENT_ACCUMULATE_EVERY = 8
LEARNING_RATE = 1e-4
VALIDATE_EVERY = 100
PRIME_LENGTH = 128
GENERATE_EVERY = 500
SEQ_LEN = 8192
GENERATE_LENGTH = 1024
# helpers
def cycle(loader):
while True:
for data in loader:
yield data
def decode_token(token):
return str(chr(max(32, token)))
def decode_tokens(tokens):
return "".join(list(map(decode_token, tokens)))
# instantiate transformer
model = HierarchicalTransformer(
num_tokens = 256,
dim = 1024,
depth = 8,
seq_len = SEQ_LEN,
use_flash_attn = True,
compress_factor = 32
).cuda()
# prepare enwik8 data
with gzip.open("./data/enwik8.gz") as file:
data = np.frombuffer(file.read(int(95e6)), dtype=np.uint8).copy()
np_train, np_valid = np.split(data, [int(90e6)])
data_train, data_val = torch.from_numpy(np_train), torch.from_numpy(np_valid)
class TextSamplerDataset(Dataset):
def __init__(self, data, seq_len):
super().__init__()
self.data = data
self.seq_len = seq_len
def __getitem__(self, index):
rand_start = torch.randint(0, self.data.size(0) - self.seq_len, (1,))
full_seq = self.data[rand_start : rand_start + self.seq_len + 1].long()
return full_seq.cuda()
def __len__(self):
return self.data.size(0) // self.seq_len
train_dataset = TextSamplerDataset(data_train, SEQ_LEN)
val_dataset = TextSamplerDataset(data_val, SEQ_LEN)
train_loader = cycle(DataLoader(train_dataset, batch_size=BATCH_SIZE))
val_loader = cycle(DataLoader(val_dataset, batch_size=BATCH_SIZE))
# optimizer
optim = Adam(model.parameters(), lr = LEARNING_RATE)
# training
for i in tqdm.tqdm(range(NUM_BATCHES), mininterval = 10.0, desc = "training"):
model.train()
for _ in range(GRADIENT_ACCUMULATE_EVERY):
loss, (ce_loss, recon_loss) = model(next(train_loader), return_loss = True)
loss.backward(loss / GRADIENT_ACCUMULATE_EVERY)
print(f"training loss: {ce_loss.item()}")
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optim.step()
optim.zero_grad()
if i % VALIDATE_EVERY == 0:
model.eval()
with torch.no_grad():
loss, (ce_loss, recon_loss) = model(next(val_loader), return_loss = True)
print(f"validation loss: {ce_loss.item()}")
if i % GENERATE_EVERY == 0:
model.eval()
inp = random.choice(val_dataset)[:PRIME_LENGTH]
prime = decode_tokens(inp)
print(f"%s \n\n %s", (prime, "*" * 100))
sample = model.generate(inp[None, ...], GENERATE_LENGTH)
output_str = decode_tokens(sample[0])
print(output_str, "\n")
{
"version": "1.0",
"truncation": null,
"padding": null,
"added_tokens": [
{
"id": 0,
"content": "<unk>",
"single_word": false,
"lstrip": false,
"rstrip": false,
"normalized": true,
"special": true
},
{
"id": 1,
"content": "<s>",
"single_word": false,
"lstrip": false,
"rstrip": false,
"normalized": true,
"special": true
},
{
"id": 2,
"content": "</s>",
"single_word": false,
"lstrip": false,
"rstrip": false,
"normalized": true,
"special": true
}
],
"normalizer": {
"type": "Sequence",
"normalizers": [
{
"type": "Prepend",
"prepend": "▁"
},
{
"type": "Replace",
"pattern": {
"String": " "
},
"content": "▁"
}
]
},
"pre_tokenizer": null,
"post_processor": {
"type": "TemplateProcessing",
"single": [
{
"SpecialToken": {
"id": "<s>",
"type_id": 0
}
},
{
"Sequence": {
"id": "A",
"type_id": 0
}
}
],
"pair": [
{
"SpecialToken": {
"id": "<s>",
"type_id": 0
}
},
{
"Sequence": {
"id": "A",
"type_id": 0
}
},
{
"SpecialToken": {
"id": "<s>",
"type_id": 1
}
},
{
"Sequence": {
"id": "B",
"type_id": 1
}
}
],
"special_tokens": {
"<s>": {
"id": "<s>",
"ids": [
1
],
"tokens": [
"<s>"
]
}
}
},
"decoder": {
"type": "Sequence",
"decoders": [
{
"type": "Replace",
"pattern": {
"String": "▁"
},
"content": " "
},
{
"type": "ByteFallback"
},
{
"type": "Fuse"
},
{
"type": "Strip",
"content": " ",
"start": 1,
"stop": 0
}
]
}
}
#include "q_gemm.cuh"
#include "util.cuh"
#include "matrix_view.cuh"
#include "../config.h"
// #include <cuda/pipeline>
// #include <mma.h>
#define BLOCK_KN_SIZE 512
#define MAX_GROUPS_IN_BLOCK (BLOCK_KN_SIZE / 32)
#define MAX_COUNT_M 2
#define CLEAR_N_SIZE 256
//#define DEBUG
#include "q_gemm_dq.cuh"
typedef void (*fp_gemm_half_q_half_kernel)
(
const half*,
const uint32_t*,
const uint32_t*,
const half*,
const uint16_t*,
half*,
const int,
const int,
const int,
const int,
const int,
const uint16_t*,
const int,
const int,
const int,
const int,
const int,
const int
);
template <bool first_block, int m_count>
__global__ void gemm_half_q_half_kernel
(
const half* a,
const uint32_t* b_q_weight,
const uint32_t* b_q_scale,
const half* b_q_scale_max,
const uint16_t* b_q_groups,
half* c,
const int size_m,
const int size_n,
const int size_k,
const int groups,
const int groupsize,
const uint16_t* __restrict__ b_q_perm,
const int rows_8,
const int rows_6,
const int rows_5,
const int rows_4,
const int rows_3,
const int rows_2
)
{
MatrixView_half a_(a, size_m, size_k);
MatrixView_half_rw c_(c, size_m, size_n);
MatrixView_q4_row b_q_scale_(b_q_scale, groups, size_n);
int t = threadIdx.x;
// Block
int offset_n = blockIdx.x * BLOCK_KN_SIZE;
int offset_m = blockIdx.y * m_count;
int offset_k = blockIdx.z * BLOCK_KN_SIZE;
int end_n = min(offset_n + BLOCK_KN_SIZE, size_n);
int end_m = min(offset_m + m_count, size_m);
int end_k = min(offset_k + BLOCK_KN_SIZE, size_k);
int n = offset_n + t;
// Preload block_a
__shared__ half block_a[m_count][BLOCK_KN_SIZE];
if (offset_k + t < end_k)
{
for (int m = 0; m < m_count; ++m)
{
const half* a_ptr = a_.item_ptr(offset_m + m, 0);
half* block_a_ptr = block_a[m];
half a0 = a_ptr[b_q_perm[offset_k + t]];
block_a_ptr[t] = a0;
}
}
__syncthreads();
if (n >= size_n) return;
// for (int xs_n = 0; xs_n < size_n - BLOCK_KN_SIZE;
// Advance to subblock
// int sub_offset_k = SUBBLOCK_K_SIZE * threadIdx.y;
// offset_k += sub_offset_k;
// end_k = min(offset_k + SUBBLOCK_K_SIZE, size_k);
// if (threadIdx.y > 0) return;
// int sub_offset_k = 0;
// Find initial group
int group = offset_k / groupsize;
// Preload scales
half scales[MAX_GROUPS_IN_BLOCK];
int groups_in_block = DIVIDE((end_k - offset_k), groupsize);
for (int g = 0; g < groups_in_block; g++)
{
half s = dq_scale(b_q_scale_.item(group + g, n), b_q_scale_max[group + g]);
scales[g] = s;
}
// Find initial q row
int pre_rows_8 = min(rows_8, offset_k);
int pre_rows_6 = offset_k > rows_8 ? min(rows_6, offset_k) - rows_8 : 0;
int pre_rows_5 = offset_k > rows_6 ? min(rows_5, offset_k) - rows_6 : 0;
int pre_rows_4 = offset_k > rows_5 ? min(rows_4, offset_k) - rows_5 : 0;
int pre_rows_3 = offset_k > rows_4 ? min(rows_3, offset_k) - rows_4 : 0;
int pre_rows_2 = offset_k > rows_3 ? min(rows_2, offset_k) - rows_3 : 0;
int qk = 0;
qk += pre_rows_8 / 32 * 8;
qk += pre_rows_6 / 32 * 6;
qk += pre_rows_5 / 32 * 5;
qk += pre_rows_4 / 32 * 4;
qk += pre_rows_3 / 32 * 3;
qk += pre_rows_2 / 32 * 2;
const uint32_t* b_ptr = b_q_weight + qk * size_n + n;
const half* a_ptr = &block_a[0][0];
int a_stride = BLOCK_KN_SIZE;
// const half* a_ptr = a_.item_ptr(offset_m, 0);
// int a_stride = size_k;
half qs_h = scales[0];
int scales_idx = 0;
int nextgroup = offset_k + groupsize;
// Column result
half2 block_c[m_count] = {};
// Dot product over groups
int k = offset_k;
while (k < rows_8 && k < end_k)
{
int end_k_sg = min(min(k + 128, rows_6), end_k);
uint32_t q_0[8], q_1[8];
load_8(b_ptr, size_n, q_0);
qdot_8bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_8bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_8bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_8bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
while (k < rows_6 && k < end_k)
{
int end_k_sg = min(min(k + 128, rows_5), end_k);
uint32_t q_0[6], q_1[6];
load_6(b_ptr, size_n, q_0);
qdot_6bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_6bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_6bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_6bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
while (k < rows_5 && k < end_k)
{
int end_k_sg = min(min(k + 128, rows_4), end_k);
uint32_t q_0[5], q_1[5];
load_5(b_ptr, size_n, q_0);
qdot_5bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_5bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_5bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_5bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
// while (k + 128 < rows_4 && k + 128 < end_k)
// {
// uint32_t q_0[8], q_1[8];
// load_8(b_ptr, size_n, q_0);
// load_8(b_ptr, size_n, q_1);
// qdot_4bit_64<m_count>(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
// qdot_4bit_64<m_count>(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1);
// }
while (k < rows_4 && k < end_k)
{
int end_k_sg = min(min(k + 128, rows_3), end_k);
uint32_t q_0[4], q_1[4];
load_4(b_ptr, size_n, q_0);
qdot_4bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_4bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_4bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_4bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
// while (k + 128 < rows_3 && k + 128 < end_k)
// {
// uint32_t q_0[6], q_1[6];
// load_6(b_ptr, size_n, q_0);
// load_6(b_ptr, size_n, q_1);
// qdot_3bit_64<m_count>(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
// qdot_3bit_64<m_count>(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1);
// }
while (k < rows_3 && k < end_k)
{
int end_k_sg = min(min(k + 128, rows_2), end_k);
uint32_t q_0[3], q_1[3];
load_3(b_ptr, size_n, q_0);
qdot_3bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_3bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_3bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_3bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
// while (k + 128 < rows_2 && k + 128 < end_k)
// {
// uint32_t q_0[8];
// load_8(b_ptr, size_n, q_0);
// qdot_2bit_128<m_count>(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
// }
while (k < rows_2 && k < end_k)
{
int end_k_sg = min(k + 128, end_k);
uint32_t q_0[2], q_1[2];
load_2(b_ptr, size_n, q_0);
qdot_2bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_2bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
qdot_2bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
qdot_2bit_32<m_count>(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
}
// Accumulate column sums in c
for (int m = 0; m < m_count; m++) atomicAdd(c_.item_ptr(offset_m + m, n), __hadd(block_c[m].x, block_c[m].y));
//for (int m = 0; m < m_count; m++) c_.set(offset_m + m, n, block_c[m]);
}
fp_gemm_half_q_half_kernel pick_gemm_half_q_half_kernel(bool first_block, const int m_count)
{
if (m_count == 1) return gemm_half_q_half_kernel<true, 1>;
if (m_count == 2) return gemm_half_q_half_kernel<true, 2>;
// if (m_count == 3) return gemm_half_q_half_kernel<true, 3>;
// if (m_count == 4) return gemm_half_q_half_kernel<true, 4>;
// if (m_count == 5) return gemm_half_q_half_kernel<true, 5>;
// if (m_count == 6) return gemm_half_q_half_kernel<true, 6>;
// if (m_count == 7) return gemm_half_q_half_kernel<true, 7>;
// if (m_count == 8) return gemm_half_q_half_kernel<true, 8>;
return NULL;
}
void gemm_half_q_half_cuda_part
(
const half* a,
QMatrix* b,
half* c,
int size_m,
int size_n,
int size_k,
int count_m
)
{
dim3 blockDim, gridDim;
blockDim.x = BLOCK_KN_SIZE;
blockDim.y = 1;
blockDim.z = 1;
gridDim.x = DIVIDE(size_n, BLOCK_KN_SIZE);
gridDim.y = DIVIDE(size_m, count_m);
gridDim.z = DIVIDE(size_k, BLOCK_KN_SIZE);
fp_gemm_half_q_half_kernel kernel = pick_gemm_half_q_half_kernel(true, count_m);
kernel<<<gridDim, blockDim>>>
(
a,
b->cuda_q_weight,
b->cuda_q_scale,
b->cuda_q_scale_max,
b->cuda_q_groups,
c,
size_m,
size_n,
size_k,
b->groups,
b->groupsize,
b->cuda_q_perm,
b->rows_8,
b->rows_6,
b->rows_5,
b->rows_4,
b->rows_3,
b->rows_2
);
}
void gemm_half_q_half_cuda
(
cublasHandle_t cublas_handle,
const half* a,
QMatrix* b,
half* c,
int size_m,
int size_n,
int size_k,
bool clear,
half* temp_dq
)
{
if (size_m >= MAX_Q_GEMM_ROWS)
{
// Reconstruct FP16 matrix, then cuBLAS
//DBGI3(size_m, size_n, size_k);
if (!temp_dq) temp_dq = b->temp_dq;
b->reconstruct(temp_dq);
cublasSetMathMode(cublas_handle, CUBLAS_TENSOR_OP_MATH);
//DBGI3(size_m, size_n, size_k);
const half alpha = __float2half(1.0f);
const half beta = clear ? __float2half(0.0f) : __float2half(1.0f);
cublasHgemm(cublas_handle,
CUBLAS_OP_N,
CUBLAS_OP_N,
size_n,
size_m,
size_k,
&alpha,
temp_dq,
size_n,
a,
size_k,
&beta,
c,
size_n);
// const float alpha = 1.0f;
// const float beta = clear ? 0.0f : 1.0f;
// cublasSgemmEx(cublas_handle,
// CUBLAS_OP_N,
// CUBLAS_OP_N,
// size_n,
// size_m,
// size_k,
// &alpha,
// temp_dq,
// CUDA_R_16F,
// size_n,
// a,
// CUDA_R_16F,
// size_k,
// &beta,
// c,
// CUDA_R_16F,
// size_n);
}
else
{
// Quantized matmul
if (clear) clear_tensor_cuda(c, size_m, size_n);
int max_chunks = size_m / MAX_COUNT_M;
int last_chunk = max_chunks * MAX_COUNT_M;
int last_chunk_size = size_m - last_chunk;
// DBGI3(size_m, size_n, size_k);
// DBGI3(max_chunks, last_chunk, last_chunk_size);
if (max_chunks)
gemm_half_q_half_cuda_part(a, b, c, last_chunk, size_n, size_k, MAX_COUNT_M);
if (last_chunk_size)
gemm_half_q_half_cuda_part(a + last_chunk * size_k, b, c + last_chunk * size_n, last_chunk_size, size_n, size_k, last_chunk_size);
}
}
__global__ void clear_kernel
(
half* __restrict__ c,
const int size_m,
const int size_n
)
{
int m = blockIdx.y;
int n = (blockIdx.x * CLEAR_N_SIZE + threadIdx.x) * 8;
if (n >= size_n) return;
int4* c_ptr = (int4*)(c + m * size_n + n);
*c_ptr = {};
}
void clear_tensor_cuda
(
half* c,
int size_m,
int size_n
)
{
dim3 blockDim, gridDim;
blockDim.x = CLEAR_N_SIZE;
blockDim.y = 1;
gridDim.x = DIVIDE(size_n / 8, CLEAR_N_SIZE);
gridDim.y = size_m;
clear_kernel<<<gridDim, blockDim>>>(c, size_m, size_n);
}
#!/usr/bin/env python3
import argparse
import torch
import torch.nn as nn
from datasets import load_dataset
from gptq_triton import load_quant
from tqdm import tqdm
from transformers import AutoTokenizer, LlamaForCausalLM
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, help='Path to model, either a HuggingFace model or a quantized model')
parser.add_argument('--quant', action='store_true', help='Whether the model is quantized')
parser.add_argument('--stride', type=int, default=512, help='Stride for calculating perplexity')
parser.add_argument('--context-length', type=int, default=2048, help='Length of context to use')
def main():
args = parser.parse_args()
if not args.quant:
model = get_llama(args.model)
model.eval()
model.to('cuda')
else:
model = load_quant(args.model)
model.eval()
model.to('cuda')
# NOTE: Setting use_fast=False for now, as the alternative was an order of magnitude slower on a recent `transformers` commit
tokenizer = AutoTokenizer.from_pretrained(args.model, use_fast=False)
context_length = model.seqlen if args.context_length is None else args.context_length
for dataset in ['wikitext-2', 'ptb', 'c4']:
ppl = calculate_perplexity(model, tokenizer, dataset, max_length=context_length, stride=args.stride)
print(f"{dataset} perplexity: {ppl}")
def get_llama(model: str):
"""
Load a pretrained Llama model
"""
def skip(*args, **kwargs):
pass
# NOTE: This is a nasty hack, but it speeds up model building by a huge amount
old_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
# Restore the old initializers
torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = old_inits
return model
def get_dataset(dataset_name: str, tokenizer) -> torch.Tensor:
if dataset_name == "wikitext-2":
test = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")
encodings = tokenizer("\n\n".join(test["text"]), return_tensors="pt").input_ids
elif dataset_name == 'ptb':
test = load_dataset("ptb_text_only", 'penn_treebank', split="validation")
encodings = tokenizer("\n\n".join(test["sentence"]), return_tensors="pt").input_ids
elif dataset_name == 'c4':
# WARNING: Many of the files in the allenai/c4 repo are marked as "Unsafe" by HuggingFace, possibly containing a virus. This particular file is not, and I doubt it's an issue, but worth noting.
test = load_dataset('allenai/c4', 'allenai--c4', data_files={'validation': 'en/c4-validation.00000-of-00008.json.gz'}, split='validation')
encodings = [tokenizer(x, return_tensors="pt").input_ids for x in test['text'][:1000]]
encodings = torch.cat(encodings, dim=1)
else:
raise ValueError(f"Unknown dataset {dataset_name}")
return encodings
def calculate_perplexity(model, tokenizer, dataset: str, max_length: int, stride: int = 512) -> float:
print("Loading dataset...")
encodings = get_dataset(dataset, tokenizer)
seq_len = encodings.size(1)
print("Calculating perplexity...")
print(f"Sequence length: {seq_len}")
print(f"Max length: {max_length}")
print(f"Stride: {stride}")
nlls = []
prev_end_loc = 0
for begin_loc in (pbar := tqdm(range(0, seq_len - 1, stride))):
end_loc = min(seq_len - 1, begin_loc + max_length)
trg_len = end_loc - prev_end_loc # How many tokens we want to predict
input_ids = encodings[:, begin_loc:end_loc+1].to('cuda') # +1 for the labels
with torch.no_grad():
# Ask the model for logits
# NOTE: Instead of calling HF's model wrapper, we call the model directly to hopefully cut down on some memory overhead
outputs = model.model(input_ids[:, :-1], use_cache=False)
logits = model.lm_head(outputs[0][..., -trg_len:, :])
# The last trg_len tokens are the labels
labels = input_ids[:, -trg_len:].contiguous()
# Compute the NLL for this batch using flattened logits and labels
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(logits.view(-1, logits.size(-1)), labels.view(-1))
nlls.append(loss.to('cpu').to(torch.float32))
ppl = torch.exp(torch.stack(nlls).mean())
pbar.set_description(f"Perplexity: {ppl:.2f}")
prev_end_loc = end_loc
if end_loc == (seq_len - 1):
break
ppl = torch.exp(torch.stack(nlls).mean())
return ppl
if __name__ == '__main__':
main()
[metadata]
name = gptq_triton
version = 0.0.3
author = fpgaminer
author_email = [email protected]
description = Fast GPTQ kernels written in Triton
long_description = file: README.md
long_description_content_type = text/markdown; charset=UTF-8
url = https://github.com/fpgaminer/GPTQ-triton
keywords = gptq, triton, torch, cuda, gpu, quantization, quantize, quantized, inference, deep learning, machine learning
license = Apache License 2.0
license_file = LICENSE
classifiers =
Development Status :: 3 - Alpha
License :: OSI Approved :: Apache Software License
Intended Audience :: Developers
Programming Language :: Python :: 3
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3.8
Programming Language :: Python :: 3.9
Programming Language :: Python :: 3.10
Topic :: Scientific/Engineering :: Artificial Intelligence
Topic :: Software Development :: Libraries :: Python Modules
[options]
zip_safe = False
include_package_data = False
package_dir =
= src
packages = find:
python_requires = >=3.6
install_requires =
triton >= 2.0.0
torch >= 2.0.0
transformers
[options.packages.find]
where = src
import random
from datasets import load_dataset
def get_dataset(dataset_name: str, tokenizer, nsamples: int, seed: int, seqlen: int):
if dataset_name == "wikitext-2":
return get_wikitext2(nsamples, seed, seqlen, tokenizer)
elif dataset_name == 'ptb':
return get_ptb(nsamples, seed, seqlen, tokenizer, jointext='\n\n')
elif dataset_name == 'ptb-new':
return get_ptb(nsamples, seed, seqlen, tokenizer, jointext=' ')
elif dataset_name == 'c4':
return get_c4(nsamples, seed, seqlen, tokenizer)
else:
raise ValueError(f"Unknown dataset {dataset_name}")
def get_wikitext2(nsamples: int, seed: int, seqlen: int, tokenizer, jointext: str = '\n\n'):
traindata = load_dataset('wikitext', 'wikitext-2-raw-v1', split='train')
trainenc = tokenizer(jointext.join(traindata['text']), return_tensors='pt')
rng = random.Random(seed)
trainloader = (rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1) for _ in range(nsamples))
trainloader = [trainenc.input_ids[:, i:i+seqlen] for i in trainloader]
return trainloader
def get_ptb(nsamples: int, seed: int, seqlen: int, tokenizer, jointext: str):
traindata = load_dataset('ptb_text_only', 'penn_treebank', split='train')
trainenc = tokenizer(jointext.join(traindata['sentence']), return_tensors='pt')
rng = random.Random(seed)
trainloader = (rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1) for _ in range(nsamples))
trainloader = [trainenc.input_ids[:, i:i+seqlen] for i in trainloader]
return trainloader
def get_c4(nsamples: int, seed: int, seqlen: int, tokenizer):
# WARNING: Many of the files in the allenai/c4 repo are marked as "Unsafe" by HuggingFace, possibly containing a virus. This particular file is not, and I doubt it's an issue, but worth noting.
traindata = load_dataset('allenai/c4', 'allenai--c4', data_files={'train': 'en/c4-train.00000-of-01024.json.gz'}, split='train')
rng = random.Random(seed)
trainloader = []
for _ in range(nsamples):
while True:
i = rng.randint(0, len(traindata) - 1)
trainenc = tokenizer(traindata[i]['text'], return_tensors='pt')
if trainenc.input_ids.shape[1] >= seqlen:
break
i = rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1)
inp = trainenc.input_ids[:, i:i + seqlen]
trainloader.append(inp)
return trainloader
#!/usr/bin/env python3
"""
Benchmarks the generation speed of a model. While Benchmark.ipynb provides nice detailed performance data, it measures the kernels in isolation.
This script measures "real world" performance by running the whole model in generation mode.
It tests a grid of prompt lengths and generation lengths, and saves the timing results to `results.json`.
"""
import argparse
import itertools
import json
import os
import random
import time
import original_quant
import torch
import transformers
from gptq_triton import load_quant
from transformers import AutoTokenizer, LlamaConfig, LlamaForCausalLM
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, help='Path to model, either a HuggingFace model or a quantized model')
parser.add_argument('--quant', action='store_true', help='Whether the model is quantized')
parser.add_argument('--cuda', type=str, help='Whether to use the old CUDA kernel and format; this must be set to the path to the CUDA quantized model, and --model must be set to a HF model')
parser.add_argument('--average', type=int, default=10, help='Number of times to run each test to get an average')
def main():
args = parser.parse_args()
if args.cuda:
model = load_cuda_quant(args.model, args.cuda, 4, -1)
model.eval()
model.to('cuda')
elif not args.quant:
model = get_llama(args.model)
model.eval()
model.to('cuda')
else:
model = load_quant(args.model)
model.eval()
model.to('cuda')
tokenizer = AutoTokenizer.from_pretrained(args.model, use_fast=False)
prompt_lengths = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]
max_lengths = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]
lengths = set(itertools.product(prompt_lengths, max_lengths))
# Remove lengths that we've already tested
if os.path.exists('results.jsonl'):
with open('results.jsonl', 'r') as f:
for line in f:
line = json.loads(line)
key = (line['prompt_length'], line['max_length'])
if key in lengths:
lengths.remove(key)
# Shuffle the lengths so that we don't always test in the same order and get caching effects
lengths = list(lengths)
random.shuffle(lengths)
# TODO: For some reason the first run is always slow, so we run it once before the benchmark to warm things up
encoded_prompt = tokenizer.encode("TODO", add_special_tokens=False, return_tensors='pt').to('cuda')
_ = model.generate(
input_ids=encoded_prompt,
max_length=8,
do_sample=True,
num_return_sequences=1,
suppress_tokens=[model.generation_config.eos_token_id],
)
# Run the remaining benchmarks
with open('results.jsonl', 'a') as f:
for prompt_length, max_length in lengths:
print(f'Prompt length: {prompt_length}, max length: {max_length}')
results = []
for _ in range(args.average):
# Generate a long random string
# We do this every time to avoid caching effects
prompt = ''.join(random.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,;:!?') for _ in range(2048 * 10))
# Encode and crop down
encoded_prompt = tokenizer.encode(prompt, add_special_tokens=False, return_tensors='pt')
encoded_prompt = encoded_prompt[:, :prompt_length]
encoded_prompt = encoded_prompt.to('cuda')
start_time = time.time()
_ = model.generate(
input_ids=encoded_prompt,
max_length=max_length + prompt_length,
do_sample=True,
num_return_sequences=1,
suppress_tokens=[model.generation_config.eos_token_id], # This prevents the sampler from ending early; it must generate max_length tokens
)
end_time = time.time()
gen_time = end_time - start_time
speed = max_length / gen_time
results.append((gen_time, speed))
# Compute the average
avg_time = sum(t for t, _ in results) / len(results)
avg_speed = (max_length * len(results)) / sum(t for t, _ in results)
print(f'Average generation time: {avg_time:.2f} seconds')
print(f'Average generation speed: {avg_speed:.2f} tokens per second')
print()
f.write(json.dumps({
'prompt_length': prompt_length,
'max_length': max_length,
'average_time': avg_time,
'average_speed': avg_speed,
'runs': results,
}))
f.write("\n")
f.flush()
def get_llama(model: str):
"""
Load a pretrained Llama model
"""
def skip(*args, **kwargs):
pass
# NOTE: This is a nasty hack, but it speeds up model building by a huge amount
old_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
# Restore the old initializers
torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = old_inits
return model
def load_cuda_quant(model, checkpoint, wbits, groupsize):
"""
Load a quantized model using the old CUDA kernel
"""
config = LlamaConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
original_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
original_init_weights = transformers.modeling_utils._init_weights
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = LlamaForCausalLM(config)
torch.set_default_dtype(torch.float)
transformers.modeling_utils._init_weights = original_init_weights
torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = original_inits
model = model.eval()
layers = original_quant.find_layers(model)
for name in ['lm_head']:
if name in layers:
del layers[name]
original_quant.make_quant(model, layers, wbits, groupsize, faster=False)
del layers
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint))
model.seqlen = 2048
print('Done.')
return model
if __name__ == '__main__':
main()
VPS
Oct 12, 2023
Ignas R.
10min Read
25 Common Linux Bash Script Examples to Get You Started
Bash or Bourne-again shell is one of the most popular shells and command languages for Linux VPS enthusiasts. It was first released in 1989 and was used as the default shell for most Linux distributions ever since.
Bash scripting allows users and system administrators to automate processes and save hundreds of hours of manual work. It’s worth mentioning that Bash is also available for Windows and macOS.
This tutorial will introduce you to what bash scripting is. It features over twenty useful bash script examples to start your bash scripting journey.
What Is Bash Scripting Used For
25 Bash Scripts Examples
1. Hello World
2. Echo Command
3. Sleep Command
4. Wait Command
5. Comments
6. Get User Input
7. Loops
8. Create an Array
9. Conditional Statements
10. Functions
11. Display String Length
12. Extract String
13. Find and Replace String
14. Concatenate Strings
15. Check if a Number is Even or Odd
16. Generate Factorial of Number
17. Create Directories
18. Read Files
19. Print Files With Line Count
20. Delete Files
21. Test if File Exists
22. Check Inodes and Disk Usage
23. Send Email Example
24. Update Packages
25. Show Server Information
What Is Bash Scripting Used For
Before we move on to the topic of bash scripting use cases, we need to elaborate on what bash and bash scripting are.
Bash is a command-line interface interpreter that runs in a text window where users can manage and execute shell commands. Bash – or shell scripting – on the other hand is the process of writing a set of commands to be executed on a Linux system. A file that includes such instructions is called a bash script.
To put it simply, the bash interpreter reads the bash script and executes the commands at the same time. For example, a Linux user can execute hundreds of commands with a single click instead of inputting them one by one. For this reason, bash scripting is the go-to choice for increasing productivity, setting up automation, and eliminating repetitive tasks.
25 Bash Scripts Examples
The following section will cover 25 of the most popular bash scripting examples, including variable manipulation and echoing out various values. We will also cover functions, arrays, loops, and much more.
1. Hello World
Hello World is the most simple bash script to start with. We will create a new variable called learningbash and print out the words Hello World. First, open a new shell script file with a text editor of your choice:
nano hello.sh
Paste the following lines into it:
#!/bin/bash
#Creates a new variable with a value of "Hello World"
learningbash="Hello World"
echo $learningbash
The command-line window showcasing the output of the first bash script – Hello World
The first line (/bin/bash) is used in every bash script. It instructs the operating system to use a bash interpreter as a command interpreter.
2. Echo Command
The echo bash command can be used to print out text as well as values of variables. In the following example, we will showcase how quotation marks affect the echo command. We will start by opening a new bash script file:
nano echo.sh
This simple bash script example will create a new variable and print it out while using different quotation marks.
#!/bin/bash
provider="Hostinger"
echo 'The best hosting provider is $provider'
echo "The best hosting provider is $provider"
The command-line window shows the echo command
As you can see, if the echo bash command is used with double quotation marks ““, then the script will print out the actual value of a variable. Otherwise, if the single quotation marks ‘‘ are used, it will print out only the name of a variable.
3. Sleep Command
Sleep command halts all currently running bash scripts and puts the system to sleep. Start by creating a new bash script file:
nano sleep.sh
Then, paste in the following simple script:
#!/bin/bash
sleep 10 && echo “I’ve been sleeping for 10 seconds, I want more” && sleep 10 && echo “I’m done sleeping, thanks!”
A bash script with the sleep command. The basic idea is that it puts the system to a halt for a set amount of time
The above example starts with a simple sleep bash command that will put your system to sleep for 10 seconds. After that, we combine the previously learned echo command with sleep – this way system will sleep for 10 seconds, then print out some words, sleep again, print out some words again and end its operation.
Pro Tip
A bash script can always be terminated by clicking CTRL + C without waiting for it to finish its operation.
4. Wait Command
wait is a built-in Linux command that waits for completion of running process. The wait command is used with a particular process id or job id.
Here’s how to create a wait bash script. Begin by creating a new bash file:
nano wait.sh
Paste in the following:
#!/bin/bash
wait 1234
echo “Done”
Important! If no job ID is provided, the wait command waits until all child background jobs are completed.
5. Comments
Users can easily add comments to their bash scripts with the # symbol. It is extra useful if you’ve got a lengthy script that needs explaining on some lines.
Begin by creating a new bash script:
nano comments.sh
Then paste in the following:
#!/bin/bash
# Define a variable named Hostinger
provider="Hostinger"
# Print out the following text
echo 'The best hosting provider is $provider'
# Print out the following text with $provider variable value
echo "The best hosting provider is $provider"
The command-line window showing single line comment functionality. It's worth noting that bash comments are not displayed with the script output.
Keep in mind that bash comments are only visible on a text editor.
6. Get User Input
To take input from users, we’ll use the read bash command. First, create a new bash shell file:
nano read.sh
Then, fill it with the script below:
#!/bin/bash
echo "What is your age?"
read age
echo "Wow, you look younger than $age years old"
In the above example, an age value was entered by the user. The output was then printed via the echo command.
7. Loops
A loop is an essential tool in various programming languages. To put it simply, a bash loop is a set of instructions that are repeated until a user-specified condition is reached. Start by creating a loop bash program:
nano whileloop.sh
Then paste in the following:
#!/bin/bash
n=0
while :
do
echo Countdown: $n
((n++))
done
This will work as a countdown to infinity until you press CTRL + C to stop the script.
Now that we’ve tested the while loop, we can move on to the for loop. Create a bash file for it:
nano forloop.sh
It should contain the script below:
#!/bin/bash
for (( n=2; n<=10; n++ ))
do
echo "$n seconds"
done
A bash script showcasing the "for" loop
The script prints out numbers from 2 to 10 while adding the seconds keyword to it.
8. Create an Array
A bash array is a data structure designed to store information in an indexed way. It is extra useful if users need to store and retrieve thousands of pieces of data fast. What makes bash arrays special is that unlike any other programming language, they can store different types of elements. For example, you can use a bash array to store both strings and numbers.
Create a new file in the current directory:
nano array.sh
Combine the freshly learned for loop with a new indexed array:
#!/bin/bash
# Create an indexed array
IndexedArray=(egg burger milk)
#Iterate over the array to get all the values
for i in "${IndexedArray[@]}";do echo "$i";done
A bash script to create and print out an array
The script iterates over the IndexedArray and prints out all the values.
9. Conditional Statements
The most popular and widely used conditional statement is if. Even though the if statement is easy to write and understand, it can be used in advanced shell scripts as well.
Begin with a new bash file:
nano if.sh
Paste the code below in it:
#!/bin/bash
salary=1000
expenses=800
#Check if salary and expenses are equal
if [ $salary == $expenses ];
then
echo "Salary and expenses are equal"
#Check if salary and expenses are not equal
elif [ $salary != $expenses ];
then
echo "Salary and expenses are not equal"
fi
This script creates two new variables and compares whether they are equal or not.
10. Functions
A bash function is a set of commands that can be reused numerous times throughout a bash script. Create a new file:
nano function.sh
Then, paste in the following code – it creates a simple Hello World function.
#!/bin/bash
hello () {
echo 'Hello World!'
}
hello
11. Display String Length
There are a couple of ways of counting string length in bash. We’ll talk about the simplest. Create a file named stringlength.sh:
nano stringlength.sh
Fill it with the following:
#!/bin/bash
# Create a new string
mystring="lets count the length of this string"
i=${#mystring}
echo "Length: $i"
Here, the # operator is used to get the length of the string variable.
12. Extract String
If users need to remove unnecessary parts from strings, they can use the Bash string extraction tools. Start by creating a new bash script:
nano extractstring.sh
The following script has 4 values, 3 of them being strings. In our example, we will extract only the number value. This can be done via the cut command. First, we instruct the command that each variable is separated by a comma by using the -d flag. Then we ask the cut command to extract the 5th value.
#!/bin/bash
cut -d , -f 5 <<< "Website,Domain,DNS,SMTP,5005"
In another example, we have a string that is mixed with some numbers. We will use expr substr commands to extract only the Hostinger text value.
#!/bin/bash
expr substr "458449Hostinger4132" 7 9
13. Find and Replace String
Another useful bash script for strings is find and replace. Create a file named findreplace.sh:
nano findreplace.sh
Then paste in the following bash script:
#!/bin/bash
first="I drive a BMW and Volvo"
second="Audi"
echo "${first/BMW/"$second"}"
Find and replace script in bash
The find and replace functionality doesn’t require any special commands, it can all be done with string manipulation.
14. Concatenate Strings
Concatenation is the term used for appending one string to the end of another string. Start by creating concatenation.sh file.
nano concatenation.sh
The most simple example would be the following:
#!/bin/bash
firststring="The secret is..."
secondstring="Bash"
thirdstring="$firststring$secondstring"
echo "$thirdstring"
The above script will connect the values of firststring and secondstring variables creating a whole new thirdstring.
A more advanced example would look like this:
#!/bin/bash
firststring="The secret is..."
firststring+="Bash"
echo "$firststring"
The script uses the += operator to join the strings. With this method, you can concatenate strings with only one variable.
15. Check if a Number is Even or Odd
Odd and even numbers can be easily divided using the if statement and some simple math. Create a file named evenoddnumbers.sh:
nano evenoddnumbers.sh
The script uses the read command to read user input and divides it by 2. If the answer is 0, the number is even.
#!/bin/bash
read -p "Enter a number and I will check if its odd or even " mynumber
if [ $((mynumber%2)) -eq 0 ]
then
echo "Your number is even"
else
echo "Your number is odd."
fi
16. Generate Factorial of Number
The factorial of a number is the result of all positive descending integers. For example, the factorial of 5 would be 120:
5! = 5*4*3*2*1 = 120
Factorial scrips are very useful for users learning about recursion. Start by creating a .sh file executable:
factorial.sh
The following script will ask the user to enter a number they want to get the factorial of and use a for loop to calculate it.
#!/bin/bash
echo Enter the number you want to get factorial for
read mynumber
factorial=1
for ((i=1;i<=mynumber;i++))
do
factorial=$(($factorial*$i))
done
echo $factorial
The command-line window displaying shell script for getting factorial of a number
17. Create Directories
It is effortless to create directories in bash unless you need to create a lot of directories quickly. In the following example, we will use the bash script to create a set of directories with the same subdirectories in each.
First, create a file named directories.sh:
nano directories.sh
Then paste in the following code:
#!/bin/bash
mkdir -p {Math,English,Geography,Arts}/{notes,examresults,portfolio}
The script creates 4 main directories: Math, English, Geography, and Arts. The Notes, examresults, and portfolio subdirectories are also created inside each.
If you were to replace the / symbol in the middle with _, the script would look like this:
#!/bin/bash
mkdir -p {Math,English,Geography,Arts}_{notes,examresults,portfolio}
Here’s the output for it displaying a merge of the two directories:
A bash script to create a lot of directories quickly. The first bash case statement indicates which interpreter to use
#!/bin/bash
#Declare string S1
S1="Bash"
#Declare string S2
S2="Scripting"
if [ $S1 = $S2 ]; then
echo "Both Strings are equal"
else
echo "Strings are NOT equal"
fi
The following script will check to see if a file exists or not.
#!/bin/bash
file="./file"
if [ -e $file ]; then
echo "File exists"
else
echo "File does not exist"
fi
The result:
$ ./filetesting.sh
File does not exist
$ touch file
$ ./filetesting.sh
File exists
Similarly for example we can use while loop to check if file does not exist. This script will sleep until file does exist. Note bash negator ! which negates the -e option.
#!/bin/bash
while [ ! -e myfile ]; do
# Sleep until file does exists/is created
sleep 1
done
Bash Select
The select command allows us to prompt the user to make a selection.
#!/bin/bash
PS3='Choose one word: '
# bash select
select word in "linux" "bash" "scripting" "tutorial"
do
echo "The word you have selected is: $word"
# Break, otherwise endless loop
break
done
exit 0
The result:
$ ./select.sh
1) linux
2) bash
3) scripting
4) tutorial
Choose one word: 2
The word you have selected is: bash
Case statement conditional
The case statement makes it easy to have many different possibilities, whereas an if statement can get lengthy very quickly if you have more than a few possibilities to account for.
#!/bin/bash
echo "What is your preferred programming / scripting language"
echo "1) bash"
echo "2) perl"
echo "3) phyton"
echo "4) c++"
echo "5) I do not know !"
read case;
#simple case bash structure
# note in this case $case is variable and does not have to
# be named case this is just an example
case $case in
1) echo "You selected bash";;
2) echo "You selected perl";;
3) echo "You selected phyton";;
4) echo "You selected c++";;
5) exit
esac
The result:
$ ./case.sh
What is your preferred programming / scripting language
1) bash
2) perl
3) phyton
4) c++
5) I do not know !
3
You selected phyton
Bash quotes and quotations
Quotations and quotes are important part of bash and bash scripting. Here are some bash quotes and quotations basics.
Escaping Meta characters
Before we start with quotes and quotations we should know something about escaping meta characters. Escaping will suppress a special meaning of meta characters and therefore meta characters will be read by bash literally. To do this we need to use backslash \ character. Example:
#!/bin/bash
#Declare bash string variable
BASH_VAR="Bash Script"
# echo variable BASH_VAR
echo $BASH_VAR
#when meta character such us "$" is escaped with "\" it will be read literally
echo \$BASH_VAR
# backslash has also special meaning and it can be suppressed with yet another "\"
echo "\\"
Here’s what it looks like when we execute the script:
$ ./escape_meta.sh
Bash Script
$BASH_VAR
\
Single quotes
Single quotes in bash will suppress special meaning of every meta characters. Therefore meta characters will be read literally. It is not possible to use another single quote within two single quotes not even if the single quote is escaped by backslash.
#!/bin/bash
# Declare bash string variable
BASH_VAR="Bash Script"
# echo variable BASH_VAR
echo $BASH_VAR
# meta characters special meaning in bash is suppressed when using single quotes
echo '$BASH_VAR "$BASH_VAR"'
The result:
$ ./single_quotes.sh
Bash Script
$BASH_VAR "$BASH_VAR"
Double quotes
Double quotes in bash will suppress special meaning of every meta characters except $, \ and `. Any other meta characters will be read literally. It is also possible to use single quote within double quotes. If we need to use double quotes within double quotes bash can read them literally when escaping them with \. Example:
#!/bin/bash
#Declare bash string variable
BASH_VAR="Bash Script"
# echo variable BASH_VAR
echo $BASH_VAR
# meta characters and its special meaning in bash is
# suppressed when using double quotes except "$", "\" and "`"
echo "It's $BASH_VAR and \"$BASH_VAR\" using backticks: `date`"
The result:
$ ./double_quotes.sh
Bash Script
It's Bash Script and "Bash Script" using backticks: Thu 10 Feb 2022 10:24:15 PM EST
Bash quoting with ANSI-C style
There is also another type of quoting and that is ANSI-C. In this type of quoting characters escaped with \ will gain special meaning according to the ANSI-C standard.
\a alert (bell) \b backspace
\e an escape character \f form feed
\n newline \r carriage return
\t horizontal tab \v vertical tab
\\ backslash \` single quote
\nnn octal value of characters ( see [http://www.asciitable.com/ ASCII table] ) \xnn hexadecimal value of characters ( see [http://www.asciitable.com/ ASCII table] )