You're right, of course... Both on the cache misses and on the idea of the table to speed the process. If you have several conversions to do, it's definitively the way to go if you go for speed, and it's a nice one. I can only blame the lack of sleep yesterday ^_^
lb $t6, 0 ($s3) #$s3 is Set1
[...]
addiu $s3, $s3, 1li $t6, 0xaaaaaaaalw $t6, 0 ($s3) #$s3 is Set1ssl $t7, $t7, 1and $t3, $t6, $t7li $t4, 0 li $t3, 0x0 # A zero to test the results
li $t4, 0x1 # Number of the first set
lw $t6, ($s3) # Load set from address $s3
li $t7, 0x1 # Shifted bit for test
loop : and $t5, $t6, $t7 # Test the bit
beq $t5, $t3, zero # Result is non-zero only if the bit is set
li $v0, 1 # system call code for integer print
move $a0, $t4 # set integer to be printed
syscall # print the integer
zero : bltz $t7, end # A trick: if $t7 contains 0x80000000, it's finished
sll $t7, $t7, 1 # shift the bit one place left
addi $t4, $t4, 1 # add 1 to the set number
b loop
end : li $t2, 0x0 # A one to test the results
li $t3, 0x0 # A zero to test the results
li $t4, 0x1 # The number of the set
lw $t6, ($s3) # Load set from address $s3
li $t7, 0x32 # Max number of sets
loop : and $t5, $t6, $t2 # Test the lowest bit
beq $t5, $t3, zero # Result is non-zero only if the bit is set
li $v0, 1 # system call code for integer print
move $a0, $t4 # set integer to be printed
syscall # print the integer
zero : beq $t7, $t4, end # check whether it was the last set
srl $t6, $t6, 1 # shift the bit one place right to test next bit
addi $t4, $t4, 1 # add 1 to the set number
b loop
end : lw $t6, ($s3) # Load set from address $s3
li $t4, 0x17 # The number of the wanted set (start at 1)
addi $t5, $t4, -1 # Remove 1
srlv $t6, $t6, $t5 # Shift the word so that the interesting bit is the lowest one
li $t5, 0x01 # bit for thesting
and $t5, $t5, $t6 # keep only the lowest bit
blez end # not in set, do nothing
li $v0, 1 # system call code for integer print
move $a0, $t4 # set integer to be printed
syscall # print the integer
end :/* A program to demonstrate printing out partial contents of the call stack */
#include <iostream>
#include <iomanip>
using namespace std;
int print_stack(int k, int j){
cout << "print_stack() begins" << endl;
cout << "argument k is at &k=" << &k << " and k=" << k << endl;
cout << "argument j is at &j=" << &j << " and j=" << j << endl;
int CCC[2] = { 77777777, 88888888 } ;
cout << "Peeking from &j up, for the space of k ints" << endl ;
int *p = (&j)+k ;
for( int l = k ; l > 0 ; l-- ){
cout << p << ": " << setw(8) << hex << *p << " = " << setw(11) << dec << *p << endl ;
p -= j ;// subtractin j from an int pointer sets it to the j-th previous int
}
cout << "End of: print_stack()" << endl;
}
int ffff(int fun_arg){
cout << "fun() begins" << endl;
cout << "fun_arg is at &fun_arg=" << &fun_arg << endl;
int BBB[2] = { 444444444, 555555555 } ;
cout << "BBB is at BBB=" << BBB << endl;
print_stack(40,+1);
cout << "fun ends" << endl;
}
int main(){
cout << "main() begins\n";
int XXXX = 999999999 ;
int AAAA[2] = { 111111111, 222222222 } ;//
ffff( 333333333 );
cout << "main() ends" << endl ;
}main() begins
fun() begins
fun_arg is at &fun_arg=0x7ffff3ef9ecc
BBB is at BBB=0x7ffff3ef9ed0
print_stack() begins
argument k is at &k=0x7ffff3ef9e6c and k=40
argument j is at &j=0x7ffff3ef9e68 and j=1
Peeking from &j up, for the space of k ints
0x7ffff3ef9f08: 5c21d9c4 = 1545722308
0x7ffff3ef9f04: 0 = 0
0x7ffff3ef9f00: 0 = 0
0x7ffff3ef9efc: 3b9ac9ff = 999999999
0x7ffff3ef9ef8: 0 = 0
0x7ffff3ef9ef4: d3ed78e = 222222222
0x7ffff3ef9ef0: 69f6bc7 = 111111111
0x7ffff3ef9eec: 0 = 0
0x7ffff3ef9ee8: 400c92 = 4197522
0x7ffff3ef9ee4: 7fff = 32767
0x7ffff3ef9ee0: f3ef9f00 = -202400000
0x7ffff3ef9edc: 0 = 0
0x7ffff3ef9ed8: 0 = 0
0x7ffff3ef9ed4: 211d1ae3 = 555555555
0x7ffff3ef9ed0: 1a7daf1c = 444444444
0x7ffff3ef9ecc: 13de4355 = 333333333
0x7ffff3ef9ec8: f3ef9fe0 = -202399776
0x7ffff3ef9ec4: 0 = 0
0x7ffff3ef9ec0: 0 = 0
0x7ffff3ef9ebc: 0 = 0
0x7ffff3ef9eb8: 400c3e = 4197438
0x7ffff3ef9eb4: 7fff = 32767
0x7ffff3ef9eb0: f3ef9ee0 = -202400032
0x7ffff3ef9eac: 0 = 0
0x7ffff3ef9ea8: 0 = 0
0x7ffff3ef9ea4: 7fff = 32767
0x7ffff3ef9ea0: f3ef9fe0 = -202399776
0x7ffff3ef9e9c: 0 = 0
0x7ffff3ef9e98: 0 = 0
0x7ffff3ef9e94: 30 = 48
0x7ffff3ef9e90: 5c01cbc0 = 1543621568
0x7ffff3ef9e8c: 9 = 9
0x7ffff3ef9e88: 5c260440 = 1545995328
0x7ffff3ef9e84: 7fff = 32767
0x7ffff3ef9e80: f3ef9e80 = -202400128
0x7ffff3ef9e7c: 30 = 48
0x7ffff3ef9e78: 5c26b397 = 1546040215
0x7ffff3ef9e74: 54c5638 = 88888888
0x7ffff3ef9e70: 4a2cb71 = 77777777
0x7ffff3ef9e6c: 28 = 40
End of: print_stack()
fun ends
main() endsla $t0, printSet
li $v0, 4 #System call code for Print
la $a0, Prompt #load add.dress of prompt into $a0
syscall
li $v0, 8
la $a0, Set1
la $a1, 80
syscall #print the prompt message
li $v0, 4 #System call code for Print
la $a0, Prompt2 #load add.dress of prompt into $a0
syscall
li $v0, 8
la $a0, Set2
la $a1, 80
syscall #print the prompt message
la $s0, Set1
la $s1, Set2
move $s3, $s0
jalr $s6, $t0
move $s3, $s1
jalr $s6, $t0beq $t5, $t3, check # Result is non-zero only if the bit is setbeq $t7, $t4, back # check whether it was the last setI find a couple things strange (but that's probably just because I haven't looked carefully), but the idea is that the stack is filling up from high adresses to lower ones (while heap go the other way).
Would you mind posting or pastebin-ing the whole program?
Besides what I was saying earlier, care to specify:
The only information I have on hand is that my school's terminal uses Ubuntu 14.04, as I grabbed the output yesterday and copied it to a text file to study this morning, using plain old 'g++ stack.cpp'. If I were to guess, it's running 64-bit.
Have you tried with a 0xFFFFFFFF set to avoid the first jump?
Probably...
int a() {
b();
c();
return 0;
}
int b() {
return 0;
}
int c() {
return 0;
}
int main() {
a();
return 0;
}
You're welcome... I hope I could help, and best wishes for the test...
OK, found the bug after installing QtSpim.
li $t2, 0x0 # A one to test the results li $t2, 0x1 # A one to test the results li $t7, 0x0 # Will contain the bit string
li $t6, 0x30 # ASCII value for '0'
li $t5, 0x31 # ASCII value for '1'
li $t4, 0x0 # End-of-string character
loop : lb $t3, ($s6)
beq $t3, $t4, endstring
beq $t3, $t5, one
beq $t3, $t6, zero
b next
one : sll $t7, $t7, 1
ori $t7, $t7, 0x1
b next
zero : sll $t7, $t7, 1
next : addi $s6, $s6, 1
b loop
endstring :I agree. I'd be curious to see on which instruction the program move the arguments from a register to the stack because of the $j...
Done rewriting the whole program...
##############################################
# Program Name: Test read/write bit string
# Programmer: Koren
# Date: 10/14/2015
#############################################
.data # Data declaration section
Prompt1: .asciiz "Set1: "
Prompt2: .asciiz "Set2: "
Buffer: .space 80
Comma: .asciiz ","
NewLine: .asciiz "\n"
Union: .asciiz "Union of sets: "
Inters: .asciiz "Intersection of sets: "
Result: .asciiz "The set is: "
Bye: .asciiz "Have a nice day."
.globl main
.text
main:
li $v0, 4 # System call code for Print
la $a0, Prompt1 # Load adddress of prompt into $a0
syscall
la $t0, readSet # Use readSet to read the set from standard input
jalr $s6, $t0
move $s1, $s3 # Store a copy of the result in $s1
li $v0, 4 # System call code for Print String
la $a0, Result # Load address of msg into $a0
syscall # Print the string
la $t0, printSet # Use printSet to print the first set
jalr $s6, $t0
li $v0, 4 # System call code for Print
la $a0, Prompt2 # Load adddress of prompt into $a0
syscall
la $t0, readSet # Use readSet to read the set from standard input
jalr $s6, $t0
move $s2, $s3 # Store a copy of the result in $s2
li $v0, 4 # System call code for Print String
la $a0, Result # Load address of msg into $a0
syscall # Print the string
la $t0, printSet # Use printSet to print the second set
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Union # Load address of msg into $a0
syscall # Print the string
or $s3, $s1, $s2 # Compute the union
la $t0, printSet # Use printSet to print the union
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Inters # Load address of msg into $a0
syscall # Print the string
and $s3, $s1, $s2 # Compute the intersection
la $t0, printSet # Use printSet to print the union
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Bye # Load address of msg into $a0
syscall
li $v0, 10 # Terminate program and
syscall # Return control to the system
##############################################################
readSet: # Read from standard input, the result will be in $s3, use $t3-$t7
li $v0, 8
la $a0, Buffer
la $a1, 80
syscall
move $s3, $a0
li $t7, 0x0 # Will contain the bit string
li $t6, 0x30 # ASCII value for '0'
li $t5, 0x31 # ASCII value for '1'
li $t4, 0x0 # End-of-string character
rloop : lb $t3, ($s3)
beq $t3, $t4, endread
beq $t3, $t5, one
beq $t3, $t6, zero
b next
one : sll $t7, $t7, 1
ori $t7, $t7, 0x1
b next
zero : sll $t7, $t7, 1
next : addi $s3, $s3, 1
b rloop
endread : move $s3, $t7
jr $s6
##############################################################
printSet: # Assume the set to print is a word in $s3, will modify $t2-$t7
move $t6, $s3 # Move the set into $t6
li $t2, 0x1 # A one to test the results
li $t3, 0x0 # A zero to test the results
li $t4, 0x1 # The number of the set
li $t7, 0x20 # Max number of sets
loop: and $t5, $t6, $t2 # Test the lowest bit
beq $t5, $t3, check # Result is non-zero only if the bit is set
li $v0, 1 # System call code for integer print
move $a0, $t4 # Set integer to be printed
syscall # print the integer
li $v0, 4 # System call code for Print String
la $a0, Comma # Load address of msg into $a0
syscall # Print the string
check: beq $t7, $t4, back # check whether it was the last set
srl $t6, $t6, 1 # shift the bit one place right to test next bit
addi $t4, $t4, 1 # add 1 to the set number
b loop
back: li $v0, 4 # System call code for Print String
la $a0, NewLine # Load address of msg into $a0
syscall # Print the string
jr $s6
##############################################################Set1: 0010 0001 1001 1110 0110 0010 1001 0110
The set is: 2,3,5,8,10,14,15,18,19,20,21,24,25,30,
Set2: 0101 0010 0011 0011 0010 1101 0010 0010
The set is: 2,6,9,11,12,14,17,18,21,22,26,29,31,
Union of sets: 2,3,5,6,8,9,10,11,12,14,15,17,18,19,20,21,22,24,25,26,29,30,31,
Intersection of sets: 2,14,18,21,
Have a nice day.So, instead of the OpenGL default of "oh, something bad happened, better not show the programmer any errors ever so he loses as many hours on this as possible", you get a nice Rust panic!() that crashes the program, hopefully with a helpful error message.
Indeed... I'm just curious about when he does this exactly (just before calling cout or right at the start of the function). Not that it's important, but I'm the kind of person that love exploring those darkest bits of implementation of compilers/interpreters...
L[0:len(L)] = my_genfor i, e in enumerate(my_gen) : L[i] = edef f(L) :
for i in range(len(L)) :
yield L[-i-1]
my_gen = f(L)try:
foo()
exception
pass
# the entire object graph of the exceptional codepath starting from foo() is still around at this point.try:
foo()
exception
pass
# sys.exc_info() is valid here!#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define M 3
#define K 2
#define N 3
int A [M][K] = { {1,4}, {2,5}, {3,6} };
int B [K][N] = { {8,7,6}, {5,4,3} };
int C [M][N];
struct v {
int i; /*row*/
int j; /*column*/
};
void *runner(void *param); /*thread*/
int main(int argc, char *argv[])
{
int i,j, count = 0;
for(i = 0; i < M; i++)
{
for(j = 0; j < N; j++)
{
/*assigning row and column per thread*/
struct v *data = (struct v *) malloc(sizeof(struct v));
data->i = i;
data->j = j;
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_create(&tid,&attr,runner,data);
pthread_join(tid, NULL);
count++;
}
}
/*print matrix*/
for(i = 0; i < M; i++)
{
for(j = 0; j < N; j++)
{
printf("%d ", C[i][j]);
}
printf("\n");
}
}
void *runner(void *param)
{
struct v *data = param;
int n, sum = 0;
/*multiplication*/
for(n = 0; n< K; n++)
{
sum += A[data->i][n] * B[n][data->j];
}
C[data->i][data->j] = sum;
pthread_exit(0);
}
)You can do something similar for other OpenGL programs by running with ApiTrace. It inserts a layer between your program and your OpenGL implementation using dll injection, saving every call to disk. You can then analyse it after, replaying the trace to view your call parameters or buffer contents at any point in the execution of your program. It will automatically highlight calls with errors, and will warn about calls with poor performance.
You're most welcome, I hadn't played with assembly for some time, although I really like it, and my students have a two-weeks break, so I've some time.
I'm pretty sure it does, but maybe not they way you tried it.
la $t0, readSet # Use readSet to read the set from standard input
jalr $s6, $t0lui $s3, 0xaaaa
ori $s3, $s3, 0xaaaalui $s3, 0x2492
ori $s3, $s3, 0x4924Hey, there's at least a couple advantages working with Cygwin
There's also a win32-pthread port. I wouldn't say it's the most portable thing, but I've used them for years on Linux, Windows (and I think they worked in OS-X) without problems...You can still allocate space on the stack any time *inside* the function... You could technically perform the first cout call, for example, before reserving stack for j.
Thanks for typing this long report. It may be useful later. Tricky, indeed... The fact that Python has a weak support of variable localisation has already caused me troubles, too. It's handy sometimes to have values available outside of loops and such, but it can also be bothering, especially with GC and ressource releasing.
Can't help you directly, but if I understand well what you're doing, I can confirm it's possible, I've help a colleague doing something like this two years ago.I'm not sure if this is the best place to ask this, but is there anyone here with Simulink and LabVIEW experience? (Any Control Systems Engineer lurking here?
I was wondering if it's possible to integrate the two.
##############################################
# Program Name: Test read/write bit string
# Programmer: Koren
# Date: 10/14/2015
#############################################
.data # Data declaration section
Prompt1: .asciiz "Set1: "
Prompt2: .asciiz "Set2: "
Buffer: .space 80
Comma: .asciiz ","
NewLine: .asciiz "\n"
Union: .asciiz "Union of sets: "
Inters: .asciiz "Intersection of sets: "
Result: .asciiz "The set is: "
Bye: .asciiz "Have a nice day."
.globl main
.text
main:
li $v0, 4 # System call code for Print
la $a0, Prompt1 # Load adddress of prompt into $a0
syscall
la $t0, readSetHex # Use readSet to read the set from standard input
jalr $s6, $t0
move $s1, $s3 # Store a copy of the result in $s1
li $v0, 4 # System call code for Print String
la $a0, Result # Load address of msg into $a0
syscall # Print the string
la $t0, printSet # Use printSet to print the first set
jalr $s6, $t0
li $v0, 4 # System call code for Print
la $a0, Prompt2 # Load adddress of prompt into $a0
syscall
la $t0, readSetHex # Use readSet to read the set from standard input
jalr $s6, $t0
move $s2, $s3 # Store a copy of the result in $s2
li $v0, 4 # System call code for Print String
la $a0, Result # Load address of msg into $a0
syscall # Print the string
la $t0, printSet # Use printSet to print the second set
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Union # Load address of msg into $a0
syscall # Print the string
or $s3, $s1, $s2 # Compute the union
la $t0, printSet # Use printSet to print the union
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Inters # Load address of msg into $a0
syscall # Print the string
and $s3, $s1, $s2 # Compute the intersection
la $t0, printSet # Use printSet to print the union
jalr $s6, $t0
li $v0, 4 # System call code for Print String
la $a0, Bye # Load address of msg into $a0
syscall
li $v0, 10 # Terminate program and
syscall # Return control to the system
##############################################################
readSet: # Read from standard input, the result will be in $s3, use $t3-$t7
li $v0, 8
la $a0, Buffer
la $a1, 80
syscall
move $s3, $a0
li $t7, 0x0 # Will contain the bit string
li $t6, 0x30 # ASCII value for '0'
li $t5, 0x31 # ASCII value for '1'
li $t4, 0x0 # End-of-string character
rloop : lb $t3, ($s3)
beq $t3, $t4, endread
beq $t3, $t5, one
beq $t3, $t6, zero
b next
one : sll $t7, $t7, 1
ori $t7, $t7, 0x1
b next
zero : sll $t7, $t7, 1
next : addi $s3, $s3, 1
b rloop
endread : move $s3, $t7
jr $s6
##############################################################
readSetHex: # Read from standard input, the result will be in $s3, use $t3-$t7
li $v0, 8
la $a0, Buffer
la $a1, 80
syscall
move $s3, $a0
li $t7, 0x0 # Will contain the bit string
li $t4, 0x0 # End-of-string character
hloop : lb $t3, ($s3)
beq $t3, $t4, endreadh # Null char, end of string!
li $t5, 0x30 # Remove 48 to the char, which is ASCII of '0'
sub $t6, $t3, $t5 # Result in $t6
bltz $t6, nexth # ASCII < 48 -> do nothing
li $t5, 0x0a # Remove 10 more
sub $t2, $t6, $t5 # Result in $t2
bgez $t2, notdigit # It it's 58 or more, it's not a 0-9 digit
digit : sll $t7, $t7, 4
or $t7, $t7, $t6 # Add the digit
b nexth # Next char!
notdigit : li $t5, 0x41 # Remove 65 to the char, which is ASCII of 'A'
sub $t6, $t3, $t5 # Result in $t6
bltz $t6, nexth # ASCII < 65 -> do nothing
li $t5, 0x06 # Remove 6 more
sub $t2, $t6, $t5 # Result in $t2
bgez $t2, notupper # It it's 71 or more, it's not a A-F digit
upper : sll $t7, $t7, 4
or $t7, $t7, $t6 # Add the A-F digit
addi $t7, 0x0a
b nexth # Next char!
notupper : li $t5, 0x61 # Remove 97 to the char, which is ASCII of 'a'
sub $t6, $t3, $t5 # Result in $t6
bltz $t6, nexth # ASCII < 97 -> do nothing
li $t5, 0x06 # Remove 6 more
sub $t2, $t6, $t5 # Result in $t2
bgez $t2, nexth # It it's 103 or more, it's not a a-f digit
lower : sll $t7, $t7, 4
or $t7, $t7, $t6 # Add the a-f digit
addi $t7, 0x0a
nexth : addi $s3, $s3, 1
b hloop
endreadh : move $s3, $t7
jr $s6
##############################################################
printSet: # Assume the set to print is a word in $s3, will modify $t2-$t7
move $t6, $s3 # Move the set into $t6
li $t2, 0x1 # A one to test the results
li $t3, 0x0 # A zero to test the results
li $t4, 0x1 # The number of the set
li $t7, 0x20 # Max number of sets
loop: and $t5, $t6, $t2 # Test the lowest bit
beq $t5, $t3, check # Result is non-zero only if the bit is set
li $v0, 1 # System call code for integer print
move $a0, $t4 # Set integer to be printed
syscall # print the integer
li $v0, 4 # System call code for Print String
la $a0, Comma # Load address of msg into $a0
syscall # Print the string
check: beq $t7, $t4, back # check whether it was the last set
srl $t6, $t6, 1 # shift the bit one place right to test next bit
addi $t4, $t4, 1 # add 1 to the set number
b loop
back: li $v0, 4 # System call code for Print String
la $a0, NewLine # Load address of msg into $a0
syscall # Print the string
jr $s6
##############################################################Set1: 0xaaaaaaaa
The set is: 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
Set2: 0x24924924
The set is: 3,6,9,12,15,18,21,24,27,30,
Union of sets: 2,3,4,6,8,9,10,12,14,15,16,18,20,21,22,24,26,27,28,30,32,
Intersection of sets: 6,12,18,24,30,
Have a nice day.But you still need something like those to avoid abuses...
Great... Congratulations!Hey Koren. I managed to also get the whole aspect of: "Is 20 in the set?" from the question.
^_^
Where's that?
France... One of the main reasons is that you can't completely forfeit your rights on anything you create (and also, you can't deny any responsability for it). It's not really an issue in practice, but I'm not sure how it would work if it was challenged in court. There's also the issue that contracts (and it's considered like a contract) should be written in the official language.
Garantee, probably not (there's too many examples even with companies), but at least you have the possibility to defend yourself. So I think it's needed.
#include<stdio.h>
#include<stdlib.h>
#define ROW 10000
#define COLUMN 10000
void writeMatrixtoFile(int row, int column, int mtrx[row][column]);
int A[ROW][COLUMN];
int B[ROW][COLUMN];
int i, j;
//------------------------------------------------------------------------------
//Main function
int main()
{
int nrows, ncol;
printf("Please enter the number of rows and columns for the matrix:\n");
printf("number of rows: ");
scanf("%d", &nrows);
printf("number of columns: ");
scanf("%d", &ncol);
for(i=0;i<nrows;i++){
for(j=0;j<ncol;j++){
A[i][j]=rand() % 100 + 1;
}
}
writeMatrixtoFile(ROW, COLUMN, A[ROW][COLUMN]);
return 0;
}
//------------------------------------------------------------------------------
//This function is for writing a matrix into a file
void writeMatrixtoFile(int row, int column, int mtrx[row][column])
{
FILE *matrix=fopen("A.txt", "w");
int a=0, b=0;
for(a=0;a<row;a++)
{
for(b=0;b<column;b++)
{
fprintf(matrix, "%lf\t", mtrx[a][b]);
}
fprintf(matrix, "\n");
}
fclose(matrix);
}I'm not surprised it segfaults, I'm surprised it even compiles??
writeMatrixtoFile(ROW, COLUMN, A[ROW][COLUMN])writeMatrixtoFile(nrows, ncol, A)void writeMatrixtoFile(int row, int column, int mtrx[row][column])#define ROW 10000const int ROW=10000;Hey, there's at least a couple advantages working with Cygwin
I agree, but it's quite recent... I'm pretty sure it wasn't available when I needed thread for the first time.
I tend to avoid Cygwin compiler chain (I still enjoy it as console replacement, though). But I'm not sure it's really "crap".
)