void _start(void)
{
u8 buf[DPRINTF_BUF_SZ];
dprintf_buf=&buf[0];
function_1(1,2);
function_2(3,4);
exit(0);
}
int test_omp_section() {
#pragma omp parallel sections
{
#pragma omp section
function_1();
#pragma omp section
function_2();
}
return 0;
}
int function_under_test_1_call(void)
{
int result;
if (function_1() != 0)
{
result = __LINE__;
}
else
{
result = 0;
}
return result;
}
void model1()
{
/* clear all pixels */
glClearColor (0.0, 0.0, 0.0, 0.0);//default background for white
glClear (GL_COLOR_BUFFER_BIT);
/* print coordinate */
grid();
coordinate();
function_1();
function_2();
function_3();
function_4();
/* buffer */
glFlush();
}
int main()
{
float money2[10];
float total_before_tax, total_after_tax;
const float tax = .1;
printf("\n\nPlease enter the money values (up to 10): \n");
scanf("%f", &money2);
total_before_tax = function_1(money2, 10);
total_after_tax = total_before_tax - (total_before_tax * tax);
printf("\n\nYour total after %0.1f tax is %6.2f.\n\n", tax, total_after_tax);
return 0;
}
main ()
{int a, i, j, tmp1, n=10, aa[10], bb[10];
/* Explicitly turn off dynamic threads */
omp_set_dynamic(0);
omp_set_num_threads(4);
tmp1=0;
#pragma omp parallel shared (tmp1)
{
#pragma omp for firstprivate (tmp1) lastprivate (tmp1)
for (j= 0; j<100; ++j){
tmp1 =j;
if (omp_get_thread_num() ==0)
printf (" loop %d, tmp1 %d \n",j, tmp1);
}
}
printf (" lastprivate tmp1 = %d\n", tmp1);
function_1();
function_2();
#pragma omp parallel for private(i) lastprivate(a)
for (i=0; i<n; i++)
{
a = i+1;
printf("Thread %d has a value of a = %d for i = %d\n",
omp_get_thread_num(),a,i);
} /*-- End of parallel for --*/
printf("Value of a after parallel for: a = %d\n",a);
#pragma omp parallel for
for (i=1; i<n; i++) /* i is private by default */
{
bb[i] = (aa[i] + aa[i-1]) / 2.0;
printf ("Work on b[%d] done by thread %d \n", i, omp_get_thread_num());
}
return(0);
}
// El punto de entrada de tu programa es una función llamada main con
// retorno de tipo entero (integer).
int main() {
// Muestra la salida usando printf, para el "formato print"
// %d es un entero, \n es una nueva línea
printf("%d\n", 0); // => Muestra 0
// Todas las sentencias deben terminar con un punto y coma.
///////////////////////////////////////
// Tipos
///////////////////////////////////////
// Tienes que declarar una variable antes de usarla. La declaración de una
// variable necesites que especifiques su tipo; el tipo de una variable
// determina su tamaño en bytes.
// 'ints' (enteros) son normalmente de 4 bytes
int x_int = 0;
// 'shorts' son normalmente de 2 bytes
short x_short = 0;
// 'chars' son fijo de 1 byte
char x_char = 0;
char y_char = 'y'; // Los caracteres literales se entrecomillan con ''
// 'longs' son a menudo de 4 a 8 bytes; 'long longs' son fijo de por lo
// menos 64 bits
long x_long = 0;
long long x_long_long = 0;
// 'floats' son normalmente números de coma flotante de 32 bits
float x_float = 0.0;
// 'doubles' son normalmente números de coma flotante de 64 bits
double x_double = 0.0;
// Todos los tipos enteros pueden ser 'unsigned'. Esto significa que no
// pueden ser negativos, pero el valor máximo de una variable 'unsigned'
// es mayor que el de una no 'unsigned' del mismo tamaño.
unsigned char ux_char;
unsigned short ux_short;
unsigned int ux_int;
unsigned long long ux_long_long;
// Todos menos 'char', que es siempre de 1 byte, varían el tamaño
// dependiendo de tu máquina. sizeof(T) te dice el tamaño de una variable
// de tipo T en bytes por lo que podemos expresar el tamaño de estos tipos
// portatilmente.
// Por ejemplo,
printf("%lu\n", sizeof(int)); // => 4 (en máquinas con 'words' de 4 bytes)
// Los arrays deben ser inicializados con un tamaño concreto.
char my_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes
int my_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes
// (suponiendo que tenemos 'words' de 4-byte)
// Puedes inicializar un array a 0 así:
char my_array[20] = {0};
// Indexar un array es como en otros lenguajes -o, más bien, otros
// lenguajes son como C-
my_array[0]; // => 0
// Los arrays varían; ¡son sólo memoria!
my_array[1] = 2;
printf("%d\n", my_array[1]); // => 2
// Las cadenas (strings) son sólo arrays de 'chars' (caracteres)
// terminados en un byte NUL (0x00), representado en las cadenas como el
// carácter especial '\0'.
// (No tenemos porqué añadir el byte nulo en cadenas literales; el
// compilador lo añade al final por nosotros.)
char a_string[20] = "Esto es una cadena";
printf("%s\n", a_string); // %s se sutituye por una cadena.
/*
Te habrás dado cuenta de que a_string es solo de 18 caracteres.
El 'char' #19 es el byte nulo.
El 'char' #20 es de valor indefinido.
*/
printf("%d\n", a_string[18]); // => 0
///////////////////////////////////////
// Operadores
///////////////////////////////////////
int i1 = 1, i2 = 2; // Forma corta de declaración múltiple
float f1 = 1.0, f2 = 2.0;
// La aritmética es sencilla
i1 + i2; // => 3
i2 - i1; // => 1
i2 * i1; // => 2
i1 / i2; // => 0 (0.5, pero es truncado tras el 0)
f1 / f2; // => 0.5, más o menos épsilon
// Módulo está también
11 % 3; // => 2
// Los operadores de comparación te resultaran familiares, pero no hay
// booleanos en C. Usamos enteros (ints) en su lugar. 0 es falso,
// cualquier otra cosa es verdadero. (Los operadores de comparación
// siempre devuelven 0 o 1)
3 == 2; // => 0 (Falso)
3 != 2; // => 1 (Verdadero)
3 > 2; // => 1
3 < 2; // => 0
2 <= 2; // => 1
2 >= 2; // => 1
// La lógica funiona en enteros
!3; // => 0 (not lógico)
!0; // => 1
1 && 1; // => 1 (and lógico)
0 && 1; // => 0
0 || 1; // => 1 (or lógico)
0 || 0; // => 0
// ¡Operadores de bits!
~0x0F; // => 0xF0 (Negación)
0x0F & 0xF0; // => 0x00 (AND)
0x0F | 0xF0; // => 0xFF (OR)
0x04 ^ 0x0F; // => 0x0B (XOR)
0x01 << 1; // => 0x02 (desplazar hacia la izquierda (por 1))
0x02 >> 1; // => 0x01 (desplazar hacia la derecha (por 1))
///////////////////////////////////////
// Estructuras de Control
///////////////////////////////////////
if (0) {
printf("Yo nunca ocurro\n");
} else if (0) {
printf("Yo tampoco ocurro nunca\n");
} else {
printf("Yo me muestro\n");
}
// Mientras el bucle exista
int ii = 0;
while (ii < 10) {
printf("%d, ", ii++); // ii++ incrementa ii en uno, después de usar su valor.
} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
printf("\n");
int kk = 0;
do {
printf("%d, ", kk);
} while (++kk < 10); // ++kk incrementa kk en uno, antes de usar su valor.
// => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
printf("\n");
// Bucles 'for' también
int jj;
for (jj=0; jj < 10; jj++) {
printf("%d, ", jj);
} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
printf("\n");
///////////////////////////////////////
// Cambios de Tipo
///////////////////////////////////////
// Cada valor en C tiene un tipo, pero tu puedes ingresar un valor en
// otro tipo si quieres.
int x_hex = 0x01; // Puedes asignar hexadecimales a variables
// El cambio de tipos intentará mantener sus valores numéricos
printf("%d\n", x_hex); // => Muestra 1
printf("%d\n", (short) x_hex); // => Muestra 1
printf("%d\n", (char) x_hex); // => Muestra 1
// Los tipos se desbordan sin aviso
printf("%d\n", (char) 257); // => 1 (El valor máximo de un 'char' es 255)
// Los tipos enteros puden cambiarse a tipos de coma flotante, y viceversa
printf("%f\n", (float)100); // %f se sustituye por un 'float'
printf("%lf\n", (double)100); // %lf se sustituye por un 'double'
printf("%d\n", (char)100.0);
///////////////////////////////////////
// Punteros
///////////////////////////////////////
// Un puntero es una variable declarada para almacenar una dirección de
// memoria. Su declaración además nos dirá el tipo de dato al que apunta.
// Puedes obtener la dirección de memoria de tus variables, y después
// enlazarlas con ellos.
int x = 0;
printf("%p\n", &x); // Usa & para obtener la dirección de una variable.
// (%p se sustituye por un puntero)
// => Muestra alguna dirección de memoria;
// Los tipos de puntero terminan con * en su declaración
int* px; // px es un puntero a un 'int'
px = &x; // Almacena la dirección de x en px
printf("%p\n", px); // => Muestra alguna dirección de memoria
// Para obtener el valor de la dirección a la que apunta un puntero, pon
// * delante para desreferenciarle.
printf("%d\n", *px); // => Muestra 0, el valor de x y de la dirección a la
// que apunta px
// También puedes cambiar el valor al que está apuntando el puntero.
// Tenemos que meter la desreferencia entre paréntesis porque ++ tiene
// prioridad frente a *.
(*px)++; // Incrementa el valor al que apunta px en 1
printf("%d\n", *px); // => Muestra 1
printf("%d\n", x); // => Muestra 1
int x_array[20]; // Los arrays son una buena manera de distribuir bloques
int xx; // continuos de memoria.
for (xx=0; xx<20; xx++) {
x_array[xx] = 20 - xx;
} // Inicializa x_array a 20, 19, 18,... 2, 1
// Declara un puntero de tipo 'int' y lo inicializa para apuntar a x_array
int* x_ptr = x_array;
// x_ptr ahira apunta al primer elemento del 'array' (el entero 20).
// Esto funciona porque las 'arrays' actualmente son solo punteros a su
// primer elemento.
// Los 'arrays' son punteros a su primer elemento.
printf("%d\n", *(x_ptr)); // => Muestra 20
printf("%d\n", x_array[0]); // => Muestra 20
// Los punteros aumentan y disminuyen en función de su tipo.
printf("%d\n", *(x_ptr + 1)); // => Muestra 19
printf("%d\n", x_array[1]); // => Muestra 19
// Puedes también asigner dinamicamente bloques contiguos de memoria con
// la función malloc de la librería estándard, que toma un entero como
// argumento representando el número de bytes a asignar de la pila.
int* my_ptr = (int*) malloc(sizeof(int) * 20);
for (xx=0; xx<20; xx++) {
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx funcionaría también aquí
} // Inicializa la memoria a 20, 19, 18, 17... 2, 1 (como 'ints')
// Desreferenciando la memoria que no has asignado te dará resultados
// impredecibles
printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?
// Cuando hayas acabado con el bloque de memoría malloc, necesitas
// liberarlo o sino nadie más podrá usarlo hasta que tu programa se cierre
free(my_ptr);
// Las cadenas pueden ser 'arrays' de chars, pero normalmente se
// representan con punteros 'char':
char* my_str = "This is my very own string";
printf("%c\n", *my_str); // => 'T'
function_1();
} // fin de la función main
/* This is a call back function will perform the specified operation on the two specified integer values */
unsigned long compute_integer_math(unsigned long(*function_1)(unsigned long*,unsigned long*),unsigned long* n1,unsigned long* n2){
return function_1(n1,n2);
}
int main() {
function_1(10);
return 0;
}
TInt E32Main(void)
{
function_1();
return 0;
}
int main() {
function_1(100);
function_2(100);
return 0;
}
