system call: shmctl ();
prototype: int shmctl (int shmqid, int cmd , struct shmid_ds * buf);
Return value: 0 if successful.
-1, if it fails: errno = EACCES (no read permission, and the command is IPC_STAT)
EFAULT (the address pointed to by buf is invalid, and the commands are IPC_SET and IPC_STAT)
EIDRM (the memory segment is removed)
EINVAL (shmqid is invalid)
EPERM ( Use IPC_SET or IPC_RMID command, but the calling process does not have write permission)
IPC_STAT reads the data structure shmid_ds of a memory segment and stores it in the address pointed to by the buf parameter.
IPC_SET sets the value of element ipc_perm in the data structure shmid_ds of the memory segment. Get the value to be set from the parameter buf.
IPC_RMID marks the memory segment as removed.
The command IPC_RMID does not really remove the shared memory segment from the system kernel, but marks the memory segment as removable. The process calls the system call shmdt () out of a shared memory segment.
[Directory]
----------------------------------------------- ---------------------------------
shmdt ()
System call: shmdt ();
Call prototype: int shmdt (char * shmaddr);
Return value: If it fails, return -1: errno = EINVAL (invalid connection address)
When a process is not in a shared memory segment, it The memory segment will be detached from its address space. But this does not mean removing the shared memory segment from the system kernel. When the process is successfully detached, the element shm_nattch in the data structure shmid_ds will decrease by 1. When this value is reduced to 0, the system kernel will physically remove the memory segment from the system kernel.
[Directory]
----------------------------------------------- ---------------------------------
Threads
Threads are usually called lightweight processes. Although this name is somewhat simplified, it helps to understand the concept of threads. Because threads and processes are relatively small, relatively speaking, threads spend less CPU resources. Processes often need their own resources, but resources can be shared between threads, so threads save memory. Mach threads allow programmers to write programs that run concurrently, and these programs can run on single-processor machines or multi-processor machines. In addition, in a single-processor environment, threads can increase efficiency when applications perform operations that are likely to cause blocking and delays.
Use the subfunction pthread_create to create a new thread. It has four parameters: a thread variable used to save the thread, a thread attribute, a function to be called when the thread executes, and a parameter of this function. For example:
pthread_ta_thread;
pthread_attr_ta_thread_attribute;
void thread_function (void * argument);
char * some_argument;
pthread_create (& a_thread, a_thread_attribute, (void *) & thread_function,
(void *) & some_argument); The
thread attribute only specifies the minimum stack size that needs to be used. In future programs, the attributes of the thread can specify other values, but now most programs can use the default values. Unlike processes created using the fork system call in UNIX systems, they use the same execution point as their parent process, and threads use the parameters in pthread_create to indicate the function to start execution.
prototype: int shmctl (int shmqid, int cmd , struct shmid_ds * buf);
Return value: 0 if successful.
-1, if it fails: errno = EACCES (no read permission, and the command is IPC_STAT)
EFAULT (the address pointed to by buf is invalid, and the commands are IPC_SET and IPC_STAT)
EIDRM (the memory segment is removed)
EINVAL (shmqid is invalid)
EPERM ( Use IPC_SET or IPC_RMID command, but the calling process does not have write permission)
IPC_STAT reads the data structure shmid_ds of a memory segment and stores it in the address pointed to by the buf parameter.
IPC_SET sets the value of element ipc_perm in the data structure shmid_ds of the memory segment. Get the value to be set from the parameter buf.
IPC_RMID marks the memory segment as removed.
The command IPC_RMID does not really remove the shared memory segment from the system kernel, but marks the memory segment as removable. The process calls the system call shmdt () out of a shared memory segment.
[Directory]
----------------------------------------------- ---------------------------------
shmdt ()
System call: shmdt ();
Call prototype: int shmdt (char * shmaddr);
Return value: If it fails, return -1: errno = EINVAL (invalid connection address)
When a process is not in a shared memory segment, it The memory segment will be detached from its address space. But this does not mean removing the shared memory segment from the system kernel. When the process is successfully detached, the element shm_nattch in the data structure shmid_ds will decrease by 1. When this value is reduced to 0, the system kernel will physically remove the memory segment from the system kernel.
[Directory]
----------------------------------------------- ---------------------------------
Threads
Threads are usually called lightweight processes. Although this name is somewhat simplified, it helps to understand the concept of threads. Because threads and processes are relatively small, relatively speaking, threads spend less CPU resources. Processes often need their own resources, but resources can be shared between threads, so threads save memory. Mach threads allow programmers to write programs that run concurrently, and these programs can run on single-processor machines or multi-processor machines. In addition, in a single-processor environment, threads can increase efficiency when applications perform operations that are likely to cause blocking and delays.
Use the subfunction pthread_create to create a new thread. It has four parameters: a thread variable used to save the thread, a thread attribute, a function to be called when the thread executes, and a parameter of this function. For example:
pthread_ta_thread;
pthread_attr_ta_thread_attribute;
void thread_function (void * argument);
char * some_argument;
pthread_create (& a_thread, a_thread_attribute, (void *) & thread_function,
(void *) & some_argument); The
thread attribute only specifies the minimum stack size that needs to be used. In future programs, the attributes of the thread can specify other values, but now most programs can use the default values. Unlike processes created using the fork system call in UNIX systems, they use the same execution point as their parent process, and threads use the parameters in pthread_create to indicate the function to start execution.
Now we can compile the first program. We compile a multi-threaded application and print "Hello Wo rld" on the standard output. First, we need two thread variables, a function that can be called when a new thread starts execution. We also need to specify the information that each thread should print. One approach is to separate the strings to be printed and give each thread a string as the starting parameter. Please see the following code:
void print_message_function (void * ptr);
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = "Wo rld";
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
pthread_create (& thread2, pthread_attr_default,
(void *) & print_message_function, (void *) message2);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s ", message);
} The
program creates the first thread by calling pthread_create and takes" Hello "as its startup parameter. The parameter of the second thread is "World". When the first thread starts executing, it uses the parameter "Hello" to execute the function print_message_function. It prints "Hello" on standard output, and then ends the call to the function. The thread terminates when it leaves its initialization function, so the first thread terminates after printing "Hello". When the second thread executes, it prints "World" and then terminates. But this program has two major flaws.
First and foremost is that threads are executed simultaneously. In this way, there is no guarantee that the first thread executes the print statement first. So you probably see "World Hello" on the screen, not "Hello World". Please note that the call to exit is used by the parent thread in the main program. In this way, if the parent thread calls exit before the two child threads call the print statement, there will be no print output. This is because the exit function will exit the process and release the task at the same time, so all threads are ended. Any thread (whether parent thread or child thread) calling exit will terminate all other threads. If you want the threads to terminate separately, you can use the pthread_exit function.
We can use a method to make up for this defect. We can insert a delay program in the parent thread to give the child thread enough time to complete the print call. Similarly, a delay program is inserted before the second is called to ensure that the first thread completes the task before the second thread executes.
void print_message_function (void * ptr);
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = "Wo rld";
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
sleep (10);
pthread_create (& thread2, pthread_attr_default,
(void *) & print_message_function, (void *) message2);
sleep (10);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s", message);
pthread_exit (0);
}
Did this meet our requirements? Not so, because the time-dependent delay to perform synchronization is not reliable. The situation encountered here is the same as a distributed program and shared resources. The shared resource is a standard output device, and the distributed computing program is three threads.
In fact, there is another mistake here. The function sleep and the function exit are related to the process. When the thread calls sleep, the entire process is in a sleep state, that is, all three threads go to sleep. In this way, we did not actually solve any problems. The function that wants to make a thread sleep is pthread_delay_np. For example, to make a thread sleep for 2 seconds, use the following procedure:
struct
timespec delay; delay.tv_sec = 2;
delay.tv_nsec = 0;
pthread_delay_np (& delay);
}
[directory]
------------ -------------------------------------------------- ------------------
Thread synchronization
void print_message_function (void * ptr);
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = "Wo rld";
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
pthread_create (& thread2, pthread_attr_default,
(void *) & print_message_function, (void *) message2);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s ", message);
} The
program creates the first thread by calling pthread_create and takes" Hello "as its startup parameter. The parameter of the second thread is "World". When the first thread starts executing, it uses the parameter "Hello" to execute the function print_message_function. It prints "Hello" on standard output, and then ends the call to the function. The thread terminates when it leaves its initialization function, so the first thread terminates after printing "Hello". When the second thread executes, it prints "World" and then terminates. But this program has two major flaws.
First and foremost is that threads are executed simultaneously. In this way, there is no guarantee that the first thread executes the print statement first. So you probably see "World Hello" on the screen, not "Hello World". Please note that the call to exit is used by the parent thread in the main program. In this way, if the parent thread calls exit before the two child threads call the print statement, there will be no print output. This is because the exit function will exit the process and release the task at the same time, so all threads are ended. Any thread (whether parent thread or child thread) calling exit will terminate all other threads. If you want the threads to terminate separately, you can use the pthread_exit function.
We can use a method to make up for this defect. We can insert a delay program in the parent thread to give the child thread enough time to complete the print call. Similarly, a delay program is inserted before the second is called to ensure that the first thread completes the task before the second thread executes.
void print_message_function (void * ptr);
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = "Wo rld";
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
sleep (10);
pthread_create (& thread2, pthread_attr_default,
(void *) & print_message_function, (void *) message2);
sleep (10);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s", message);
pthread_exit (0);
}
Did this meet our requirements? Not so, because the time-dependent delay to perform synchronization is not reliable. The situation encountered here is the same as a distributed program and shared resources. The shared resource is a standard output device, and the distributed computing program is three threads.
In fact, there is another mistake here. The function sleep and the function exit are related to the process. When the thread calls sleep, the entire process is in a sleep state, that is, all three threads go to sleep. In this way, we did not actually solve any problems. The function that wants to make a thread sleep is pthread_delay_np. For example, to make a thread sleep for 2 seconds, use the following procedure:
struct
timespec delay; delay.tv_sec = 2;
delay.tv_nsec = 0;
pthread_delay_np (& delay);
}
[directory]
------------ -------------------------------------------------- ------------------
Thread synchronization
POSIX provides two methods for thread synchronization, mutex and condition variables. mutex is a simple locking method to control access to shared resources. We can create a read / write program that shares a shared buffer and use mutex to control access to the buffer.
void reader_function (void);
void writer_function (void);
char buf fer;
int buffer_has_item = 0;
pthread_mutex_t mutex;
struct timespec delay;
main ()
{
pthread_t reader;
delay.tv_sec = 2;
delay.tv_nsec = 0;
pthread_mutex_init (& mutex, pthread_mutexattr_default);
pthread_create (& reader, pthread_attr_default, (void
NULL);
writer_function ()
void writer_function (void)
{
while (1)
{
pthread_mutex_lock (& ββmutex);
if (buffer_has_item == 0)
{
buffer = make_new_item ();
buffer_has_item = 1;
}
pthread_mutex_unlock (& ββmutex lay; pthread_de & lay ;
pthread_deex ;
}
}
void reader_function (void)
{
while (1)
{
pthread_mutex_lock (& ββmutex);
if (buffer_has_item == 1)
{ consume_item
(buffer);
buffer_has_item = 0;
}
pthread_mutex_unlock (& ββmutex);
pthread_delay_np (& delay);
}
}
on the program In, we assume that the buffer can only hold one piece of information, so that the buffer has only two states, with one piece of information or no information. The delay is used to avoid that a thread will always occupy the mutex.
But the disadvantage of mutex is that it has only two states, locked and unlocked. POSIX condition variables make up for the lack of mutex by allowing threads to block and wait for another thread's signal method. When a signal is received, the blocked thread will be evoked and try to obtain the related mutex lock.
[Directory]
----------------------------------------------- ---------------------------------
Use semaphore coordination procedures
We can use semaphores to revisit the above read / write procedure. The operations involving semaphores are semaphore_up, semaphore_down, semaphore_init, semaphore_destroy, and semaphore_decrement. All these operations have only one parameter, a pointer to the semaphore target.
void reader_function (void);
void writer_function (void);
char buffer;
Semaphore writers_turn;
Semaphore readers_turn;
main ()
{
pthread_t reader;
semaphore_init (& readers_turn);
semaphore_init (& writers_turn);
/ * writer must go first * /
semaphore_down (& readers ;
pthread_create (& reader, pthread_attr_default,
(void *) & reader_function, NULL);
writer _ function ();
}
void writer_function (void)
{
while (1)
{
semaphore_down (& writers_turn);
Bu FFER = make_new_item ();
semaphore_up (& readers_turn);
}
}
void reader_function (void)
{
the while (. 1)
{
semaphore_down (& readers_turn);
consume_item (Buffer);
semaphore_up (& writers_turn);
}
}
This example also Not all functions of general semaphores are fully utilized. We can rewrite the "Hello world" program using semaphores:
void print_message_function (void * ptr);
Semaphore child_counter;
Semaphore worlds_turn;
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = " Wo rld ";
semaphore_init (& child_counter);
semaphore_init (& worlds_turn);
semaphore_down (& worlds_turn); / * world goes second * /
semaphore_decrement (& child_counter); / * value now 0 * /
semaphore_decrement (& child_counter); / * value now -1 * /
/ *
* child_counter now must be up -ed 2 times for a thread blocked on it
* to be released
*
* /
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
semaphore_down (& worlds_turn);
pthread_create (& thread2, pthread_attr_default,
(void * ) & print_message_function, (void *) message2);
semaphore_down (& child_counter);
/ * not really necessary to destroy since we are exiting anyway * /
semaphore_destroy (& child_counter);
semaphore_destroy (& worlds_turn);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s", message);
fflush (stdout) ;
semaphore_up (& worlds_turn);
semaphore_up (& child_counter);
pthread _ exit (0);
} The
void reader_function (void);
void writer_function (void);
char buf fer;
int buffer_has_item = 0;
pthread_mutex_t mutex;
struct timespec delay;
main ()
{
pthread_t reader;
delay.tv_sec = 2;
delay.tv_nsec = 0;
pthread_mutex_init (& mutex, pthread_mutexattr_default);
pthread_create (& reader, pthread_attr_default, (void
NULL);
writer_function ()
void writer_function (void)
{
while (1)
{
pthread_mutex_lock (& ββmutex);
if (buffer_has_item == 0)
{
buffer = make_new_item ();
buffer_has_item = 1;
}
pthread_mutex_unlock (& ββmutex lay; pthread_de & lay ;
pthread_deex ;
}
}
void reader_function (void)
{
while (1)
{
pthread_mutex_lock (& ββmutex);
if (buffer_has_item == 1)
{ consume_item
(buffer);
buffer_has_item = 0;
}
pthread_mutex_unlock (& ββmutex);
pthread_delay_np (& delay);
}
}
on the program In, we assume that the buffer can only hold one piece of information, so that the buffer has only two states, with one piece of information or no information. The delay is used to avoid that a thread will always occupy the mutex.
But the disadvantage of mutex is that it has only two states, locked and unlocked. POSIX condition variables make up for the lack of mutex by allowing threads to block and wait for another thread's signal method. When a signal is received, the blocked thread will be evoked and try to obtain the related mutex lock.
[Directory]
----------------------------------------------- ---------------------------------
Use semaphore coordination procedures
We can use semaphores to revisit the above read / write procedure. The operations involving semaphores are semaphore_up, semaphore_down, semaphore_init, semaphore_destroy, and semaphore_decrement. All these operations have only one parameter, a pointer to the semaphore target.
void reader_function (void);
void writer_function (void);
char buffer;
Semaphore writers_turn;
Semaphore readers_turn;
main ()
{
pthread_t reader;
semaphore_init (& readers_turn);
semaphore_init (& writers_turn);
/ * writer must go first * /
semaphore_down (& readers ;
pthread_create (& reader, pthread_attr_default,
(void *) & reader_function, NULL);
writer _ function ();
}
void writer_function (void)
{
while (1)
{
semaphore_down (& writers_turn);
Bu FFER = make_new_item ();
semaphore_up (& readers_turn);
}
}
void reader_function (void)
{
the while (. 1)
{
semaphore_down (& readers_turn);
consume_item (Buffer);
semaphore_up (& writers_turn);
}
}
This example also Not all functions of general semaphores are fully utilized. We can rewrite the "Hello world" program using semaphores:
void print_message_function (void * ptr);
Semaphore child_counter;
Semaphore worlds_turn;
main ()
{
pthread_t
thread1, thread2 ; char * message1 = "Hello";
char * message2 = " Wo rld ";
semaphore_init (& child_counter);
semaphore_init (& worlds_turn);
semaphore_down (& worlds_turn); / * world goes second * /
semaphore_decrement (& child_counter); / * value now 0 * /
semaphore_decrement (& child_counter); / * value now -1 * /
/ *
* child_counter now must be up -ed 2 times for a thread blocked on it
* to be released
*
* /
pthread_create (& thread1, pthread_attr_default,
(void *) & print_message_function, (void *) message1);
semaphore_down (& worlds_turn);
pthread_create (& thread2, pthread_attr_default,
(void * ) & print_message_function, (void *) message2);
semaphore_down (& child_counter);
/ * not really necessary to destroy since we are exiting anyway * /
semaphore_destroy (& child_counter);
semaphore_destroy (& worlds_turn);
exit (0);
}
void print_message_function (void * ptr)
{
char * message;
message = (char *) ptr;
printf ("% s", message);
fflush (stdout) ;
semaphore_up (& worlds_turn);
semaphore_up (& child_counter);
pthread _ exit (0);
} The
semaphore child _ counter is used to force the parent thread to block until two child threads execute the printf statement and the subsequent semaphore_up (& child_counter) statement. carried out.
Semaphore.h
#ifndef SEMAPHORES
#define SEMAPHORES
#include
#include
typedef struct Semaphore
{
int v;
pthread_mutex_t mutex;
pthread_cond_t cond;
}
S emaphore;
int semaphore_down (Semaphore * S);
int semaphore_decrement (Semaphore * S);
int semaphore_up (Semaphore * S);
void semaphore_destroy (Semaphore * S);
void semaphore_init (Semaphore * S);
int semaphore_value ( semaphore * S);
int tw_pthread_cond_signal (pthread_cond_t * C);
int tw_pthread_cond_wait (pthread_cond_t * C, pthread_mutex_t * m);
int tw_pthread_mutex_unlock (pthread_mutex_t * m);
int tw_pthread_mutex_lock (pthread_mutex_t * m);
void do_error (char * MSG);
# endif
Semaphore.c
#include "semaphore.h"
/ *
* function must be called prior to semaphore use.
*
* /
void
semaphore_init (Semaphore * s)
{
s-> v = 1;
if (pthread_mutex_init (& (s-> mutex), pthread_mutexattr_default) == -1)
do_error ("Error setting up semaphore mutex");
if ( pthread_cond_init (& (s-> cond), pthread_condattr_default) == -1)
do_error ("Error setting up semaphore condition signal");
* function should be called when there is no longer a need for
* the semaphore.
*
* /
void
semaphore_destroy (Semaphore * s)
{
if (pthread_mutex_destroy (& (s-> mutex)) == -1)
do_error ("Error destroying semaphore mutex");
if (pthread_cond_destroy (& (s->cond)) == -1)
do_error ("Error destroying semaphore condition signal");
}
/ *
* function increments the semaphore and signals any threads that
* are blocked waiting a change in the semaphore.
*
* /
int
semaphore_up (Semaphore * s)
{
int value_after_op;
tw_pthread_mutex_lock ( & (s-> mutex));
(s-> v) + +;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
tw_pthread_cond_signal (& (s-> cond));
return (value_after_op );
}
/ *
* function decrements the semaphore and blocks if the semaphore is
* <= 0 until another thread signals a change.
*
* /
int
semaphore_down (Semaphore * s)
{
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex));
while (s-> v <= 0)
{
tw_pthread_cond_wait (& (s-> cond), & (s-> mutex) );
}
(s-> v)--;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ *
* function does NOT block but simply decrements the semaphore.
* should not be used instead of down-only for programs where
* multiple threads must up on a semaphore before another thread
* can go down, ie, allows programmer to set the semaphore to
* a negative value prior to using it for synchronization.
*
* /
int
semaphore_decrement (Semaphore * s)
(
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex)); s-> v--
;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ *
* function returns the value of the semaphore at the time the
* critical section is accessed. obviously the value is not guarenteed
* after the function unlocks the critical section. provided only
* for casual debugging, a better approach is for the programmar to
* protect one semaphore with another and then check its value.
* an alternative is to simply record the value returned by semaphore_up
* or semaphore_down.
*
* /
int
semaphore_value (Semaphore * s)
{
/ * not for sync * /
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex));
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ * -------------------------------------- ------------------------------ * /
/ * The following functions replace standard library functions in that * /
/ * they exit on any error returned from the system calls. Saves us * /
/ * from having to check each and every call above. * /
/ * ---------------------- ---------------------------------------------- * /
int
tw_pthread_mutex_unlock (pthread_mutex_t * m)
{
int the return_value;
IF ((pthread_mutex_unlock the return_value = (m)) == -1)
do_error ( "pthread_mutex_unlock");
return (the return_value);
}
int
Semaphore.h
#ifndef SEMAPHORES
#define SEMAPHORES
#include
#include
typedef struct Semaphore
{
int v;
pthread_mutex_t mutex;
pthread_cond_t cond;
}
S emaphore;
int semaphore_down (Semaphore * S);
int semaphore_decrement (Semaphore * S);
int semaphore_up (Semaphore * S);
void semaphore_destroy (Semaphore * S);
void semaphore_init (Semaphore * S);
int semaphore_value ( semaphore * S);
int tw_pthread_cond_signal (pthread_cond_t * C);
int tw_pthread_cond_wait (pthread_cond_t * C, pthread_mutex_t * m);
int tw_pthread_mutex_unlock (pthread_mutex_t * m);
int tw_pthread_mutex_lock (pthread_mutex_t * m);
void do_error (char * MSG);
# endif
Semaphore.c
#include "semaphore.h"
/ *
* function must be called prior to semaphore use.
*
* /
void
semaphore_init (Semaphore * s)
{
s-> v = 1;
if (pthread_mutex_init (& (s-> mutex), pthread_mutexattr_default) == -1)
do_error ("Error setting up semaphore mutex");
if ( pthread_cond_init (& (s-> cond), pthread_condattr_default) == -1)
do_error ("Error setting up semaphore condition signal");
* function should be called when there is no longer a need for
* the semaphore.
*
* /
void
semaphore_destroy (Semaphore * s)
{
if (pthread_mutex_destroy (& (s-> mutex)) == -1)
do_error ("Error destroying semaphore mutex");
if (pthread_cond_destroy (& (s->cond)) == -1)
do_error ("Error destroying semaphore condition signal");
}
/ *
* function increments the semaphore and signals any threads that
* are blocked waiting a change in the semaphore.
*
* /
int
semaphore_up (Semaphore * s)
{
int value_after_op;
tw_pthread_mutex_lock ( & (s-> mutex));
(s-> v) + +;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
tw_pthread_cond_signal (& (s-> cond));
return (value_after_op );
}
/ *
* function decrements the semaphore and blocks if the semaphore is
* <= 0 until another thread signals a change.
*
* /
int
semaphore_down (Semaphore * s)
{
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex));
while (s-> v <= 0)
{
tw_pthread_cond_wait (& (s-> cond), & (s-> mutex) );
}
(s-> v)--;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ *
* function does NOT block but simply decrements the semaphore.
* should not be used instead of down-only for programs where
* multiple threads must up on a semaphore before another thread
* can go down, ie, allows programmer to set the semaphore to
* a negative value prior to using it for synchronization.
*
* /
int
semaphore_decrement (Semaphore * s)
(
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex)); s-> v--
;
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ *
* function returns the value of the semaphore at the time the
* critical section is accessed. obviously the value is not guarenteed
* after the function unlocks the critical section. provided only
* for casual debugging, a better approach is for the programmar to
* protect one semaphore with another and then check its value.
* an alternative is to simply record the value returned by semaphore_up
* or semaphore_down.
*
* /
int
semaphore_value (Semaphore * s)
{
/ * not for sync * /
int value_after_op;
tw_pthread_mutex_lock (& ββ(s-> mutex));
value_after_op = s-> v;
tw_pthread_mutex_unlock (& ββ(s-> mutex));
return (value_after_op);
}
/ * -------------------------------------- ------------------------------ * /
/ * The following functions replace standard library functions in that * /
/ * they exit on any error returned from the system calls. Saves us * /
/ * from having to check each and every call above. * /
/ * ---------------------- ---------------------------------------------- * /
int
tw_pthread_mutex_unlock (pthread_mutex_t * m)
{
int the return_value;
IF ((pthread_mutex_unlock the return_value = (m)) == -1)
do_error ( "pthread_mutex_unlock");
return (the return_value);
}
int
tw_pthread_mutex_lock (pthread_mutex_t * m)
{
int the return_value;
IF ((return_value = pthread_mutex_lock (m)) == -1)
do_error ("pthread_mutex_lock");
return (return_value);
}
int
tw_pthread_cond_wait (pthread_cond_t * c, pthread_mutex_t * m)
(
int return_value;
if ((return_value = pthread , m)) == -1)
do_error ("pthread_cond_wait");
return (return_value);
}
int
tw_pthread_cond_signal (pthread_cond_t * c)
{
int return_value;
if ((return_value = pthread_cond_signal (c)) == -1)
do_error ("pthread_cond_signal");
return (return_value);
}
/ *
* function just prints an error message and exits
*
* /
void
do_error (char * msg)
{
perror (msg);
exit (1);
}
[directory]
------------------------- -------------------------------------------------- ----
written by undercode
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
{
int the return_value;
IF ((return_value = pthread_mutex_lock (m)) == -1)
do_error ("pthread_mutex_lock");
return (return_value);
}
int
tw_pthread_cond_wait (pthread_cond_t * c, pthread_mutex_t * m)
(
int return_value;
if ((return_value = pthread , m)) == -1)
do_error ("pthread_cond_wait");
return (return_value);
}
int
tw_pthread_cond_signal (pthread_cond_t * c)
{
int return_value;
if ((return_value = pthread_cond_signal (c)) == -1)
do_error ("pthread_cond_signal");
return (return_value);
}
/ *
* function just prints an error message and exits
*
* /
void
do_error (char * msg)
{
perror (msg);
exit (1);
}
[directory]
------------------------- -------------------------------------------------- ----
written by undercode
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦Programming Technology-Process and Thread Programming by undercode FULL
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦FRESH Premium Proxies :
t.me/UndercodeTesting
47.75.90.57 80 1 hour ago
1320 ms 70% (46) hk Hong Kong - Central Elite -
82.119.170.106 8080 1 hour ago
1049 ms 96% (44) de Germany - Berlin Elite -
85.10.219.103 1080 1 hour ago
3400 ms 44% (53) de Germany Elite -
85.10.219.97 1080 1 hour ago
3500 ms 53% (44) de Germany Elite -
85.10.219.98 1080 1 hour ago
3363 ms 47% (54) de Germany Elite -
85.10.219.100 1080 1 hour ago
2823 ms 36% (59) de Germany Elite -
88.255.63.53 8080 1 hour ago
3939 ms 14% (43) tr Turkey Elite -
182.138.160.189 8118 1 hour ago
1885 ms 25% (4) cn China Elite -
188.40.183.188 1080 1 hour ago
3501 ms 43% (45) de Germany Elite -
202.138.241.166 8080 1 hour ago
4710 ms 18% (58) id Indonesia - Bandung Elite -
203.218.82.122 8080 1 hour ago
783 ms 13% (70) hk Hong Kong - Central Elite -
218.14.108.53 8060 1 hour ago
1222 ms 36% (54) cn China - Huizhou Elite -
218.75.102.198 8000 1 hour ago
990 ms 48% (61) cn China - Hangzhou Elite -
217.219.179.60 5220 1 hour ago
3735 ms 16% (59) ir Iran Elite -
113.252.95.19 8380 1 hour ago
773 ms 19% (59) hk Hong Kong - Kowloon Elite -
124.239.216.14 8060 1 hour ago
1694 ms 34% (50) cn China - Tianjin Elite -
128.199.71.230 8080 1 hour ago
1272 ms 94% (33) sg Singapore Elite -
148.251.153.6 1080 1 hour ago
3515 ms 40% (55) de Germany Elite -
159.138.22.112 443 1 hour ago
3268 ms 60% (52) hk Hong Kong Elite -
163.204.243.151 9999 1 hour ago
0 ms 0% (56) cn China Elite -
169.57.157.148 8123 1 hour ago
535 ms 98% (38) br Brazil - SΓ£o Paulo Elite -
173.192.128.238 25 1 hour ago
343 ms 98% (39) us United States - Seattle Elite -
61.54.225.130 8060 1 hour ago
2546 ms 22% (60) cn China - Anyang Elite -
80.187.140.26 80 1 hour ago
803 ms 84% (37) de Germany Elite -
78.108.66.26 3128 1 hour ago
3931 ms 20% (50) ru Russia - Kurgan Elite -
79.104.25.218 8080 1 hour ago
4197 ms 8% (66) ru Russia - Moscow Elite -
79.137.44.85 3129 1 hour ago
2405 ms 59% (51) es Spain - Madrid Elite -
81.93.4.11 81 1 hour ago
0 ms 0% (70) fr France - Saint-Gratien Elite -
101.4.136.34 8080 1 hour ago
1004 ms 49% (41) cn China Elite -
83.168.86.1 8090 1 hour ago
3218 ms 17% (56) pl Poland - Lobez Elite -
103.216.82.22 6666 1 hour ago
4001 ms 11% (64) in India - Ahmedabad Elite -
188.120.232.181 8118 1 hour ago
917 ms 25% (49) ru Russia Elite -
188.40.183.185 1080 1 hour ago
3436 ms 56% (49) de Germany Elite -
200.108.183.2 8080 1 hour ago
2031 ms 22% (57) uy Uruguay Elite -
218.27.204.240 8000 1 hour ago
3405 ms 42% (51) cn China Elite -
@UndercodeTesting
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦FRESH Premium Proxies :
t.me/UndercodeTesting
47.75.90.57 80 1 hour ago
1320 ms 70% (46) hk Hong Kong - Central Elite -
82.119.170.106 8080 1 hour ago
1049 ms 96% (44) de Germany - Berlin Elite -
85.10.219.103 1080 1 hour ago
3400 ms 44% (53) de Germany Elite -
85.10.219.97 1080 1 hour ago
3500 ms 53% (44) de Germany Elite -
85.10.219.98 1080 1 hour ago
3363 ms 47% (54) de Germany Elite -
85.10.219.100 1080 1 hour ago
2823 ms 36% (59) de Germany Elite -
88.255.63.53 8080 1 hour ago
3939 ms 14% (43) tr Turkey Elite -
182.138.160.189 8118 1 hour ago
1885 ms 25% (4) cn China Elite -
188.40.183.188 1080 1 hour ago
3501 ms 43% (45) de Germany Elite -
202.138.241.166 8080 1 hour ago
4710 ms 18% (58) id Indonesia - Bandung Elite -
203.218.82.122 8080 1 hour ago
783 ms 13% (70) hk Hong Kong - Central Elite -
218.14.108.53 8060 1 hour ago
1222 ms 36% (54) cn China - Huizhou Elite -
218.75.102.198 8000 1 hour ago
990 ms 48% (61) cn China - Hangzhou Elite -
217.219.179.60 5220 1 hour ago
3735 ms 16% (59) ir Iran Elite -
113.252.95.19 8380 1 hour ago
773 ms 19% (59) hk Hong Kong - Kowloon Elite -
124.239.216.14 8060 1 hour ago
1694 ms 34% (50) cn China - Tianjin Elite -
128.199.71.230 8080 1 hour ago
1272 ms 94% (33) sg Singapore Elite -
148.251.153.6 1080 1 hour ago
3515 ms 40% (55) de Germany Elite -
159.138.22.112 443 1 hour ago
3268 ms 60% (52) hk Hong Kong Elite -
163.204.243.151 9999 1 hour ago
0 ms 0% (56) cn China Elite -
169.57.157.148 8123 1 hour ago
535 ms 98% (38) br Brazil - SΓ£o Paulo Elite -
173.192.128.238 25 1 hour ago
343 ms 98% (39) us United States - Seattle Elite -
61.54.225.130 8060 1 hour ago
2546 ms 22% (60) cn China - Anyang Elite -
80.187.140.26 80 1 hour ago
803 ms 84% (37) de Germany Elite -
78.108.66.26 3128 1 hour ago
3931 ms 20% (50) ru Russia - Kurgan Elite -
79.104.25.218 8080 1 hour ago
4197 ms 8% (66) ru Russia - Moscow Elite -
79.137.44.85 3129 1 hour ago
2405 ms 59% (51) es Spain - Madrid Elite -
81.93.4.11 81 1 hour ago
0 ms 0% (70) fr France - Saint-Gratien Elite -
101.4.136.34 8080 1 hour ago
1004 ms 49% (41) cn China Elite -
83.168.86.1 8090 1 hour ago
3218 ms 17% (56) pl Poland - Lobez Elite -
103.216.82.22 6666 1 hour ago
4001 ms 11% (64) in India - Ahmedabad Elite -
188.120.232.181 8118 1 hour ago
917 ms 25% (49) ru Russia Elite -
188.40.183.185 1080 1 hour ago
3436 ms 56% (49) de Germany Elite -
200.108.183.2 8080 1 hour ago
2031 ms 22% (57) uy Uruguay Elite -
218.27.204.240 8000 1 hour ago
3405 ms 42% (51) cn China Elite -
@UndercodeTesting
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦Carding 2020 How to create free .edu email
π¦ Part 1:
> Step 1: Go to this https://www.apply.vccs.edu/Home/Sign_In/Logon.aspx and solve captcha. Then Click on new user and then sign up with email.
> Step 2: To fill the detail you can use your real name and email but if you are not an US citizen then you can use this (https://www.fakeaddressgenerator.com/usa_address_generator) to generate fake user detail. [For temporary email you can go https://emailfake.com/.] For Eg:
π¦Full Name Mary N Morey
Gender female
Title Mrs.
Race Black
Birthday 11/16/1957
Social Security Number 306-90-8491
π¦[Note: Save name, username and password in notepad or somewhere it may need later]
Step 3: After filling all the detail click on submit.
Now that you have created account lets move on to part two of this tutorial.
π¦Part 2:
After creating account and loging into click on Apply Now. Select any college name from the list and click on Apply. A pop-up will open then click on Apply Now (OR CONTINUE APPLICATION) BUTTON. Then you are asked for different questions. You can answer these questions randomly or you can use the detail below to answer these questions.
First name and last name: Put the name that you have entered in part 1. Leave other field empty.
Birthdate, Social Security Number: Enter details which was generated from this https://www.fakeaddressgenerator.com/usa_address_generator .
Gender: Male/Female (as you like)
Racial or ethnic identification: White
Hispanico or Latino : No
Have you ever applied, attended β¦β¦ : No
After that click on Save and Continue.
For Mailing address use the detail generated from this link.
Is this your permanent address: Yes
You can leave telephone number blank.
Then check on I have reviewed the guidelines box and click on save and continue.
Which β¦.. high school education: I donβt have a GED/High β¦β¦.
Last date attended: 01/2017
Highest grade completed: 11th grade.
Have you ever attend β¦. : No
I have planned to earn a degreeβ¦..: No
I plan to start class: Choose any
After that click on Save and Continue.
Have you ever served β¦β¦.. military: No
Are you β¦β¦.. military: No
After that click on Save and Continue.
Parent 1 and 2: Choose any.
What is your current status?: Native USβ¦β¦
Primary spoken language: English
Do you wantβ¦β¦: No
After that click on Submit your completed application.
π¦ Part 3.
> After successfully completing the application put on your signature i.e your full name. Then you will be redirect to with all your detail. Under the student information you will get your username and temporary password. Note down that password, username and other details.
> After that you can go> if link not open try later then works because this anonymously https://bit.ly/38wwKJc and login where you will get your .edu email.
> NOTE: It will take more than 6hours for the login credentials to activate. So you will get error that your username and password is invalid
WRITTEN BY UNDER CODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦Carding 2020 How to create free .edu email
π¦ Part 1:
> Step 1: Go to this https://www.apply.vccs.edu/Home/Sign_In/Logon.aspx and solve captcha. Then Click on new user and then sign up with email.
> Step 2: To fill the detail you can use your real name and email but if you are not an US citizen then you can use this (https://www.fakeaddressgenerator.com/usa_address_generator) to generate fake user detail. [For temporary email you can go https://emailfake.com/.] For Eg:
π¦Full Name Mary N Morey
Gender female
Title Mrs.
Race Black
Birthday 11/16/1957
Social Security Number 306-90-8491
π¦[Note: Save name, username and password in notepad or somewhere it may need later]
Step 3: After filling all the detail click on submit.
Now that you have created account lets move on to part two of this tutorial.
π¦Part 2:
After creating account and loging into click on Apply Now. Select any college name from the list and click on Apply. A pop-up will open then click on Apply Now (OR CONTINUE APPLICATION) BUTTON. Then you are asked for different questions. You can answer these questions randomly or you can use the detail below to answer these questions.
First name and last name: Put the name that you have entered in part 1. Leave other field empty.
Birthdate, Social Security Number: Enter details which was generated from this https://www.fakeaddressgenerator.com/usa_address_generator .
Gender: Male/Female (as you like)
Racial or ethnic identification: White
Hispanico or Latino : No
Have you ever applied, attended β¦β¦ : No
After that click on Save and Continue.
For Mailing address use the detail generated from this link.
Is this your permanent address: Yes
You can leave telephone number blank.
Then check on I have reviewed the guidelines box and click on save and continue.
Which β¦.. high school education: I donβt have a GED/High β¦β¦.
Last date attended: 01/2017
Highest grade completed: 11th grade.
Have you ever attend β¦. : No
I have planned to earn a degreeβ¦..: No
I plan to start class: Choose any
After that click on Save and Continue.
Have you ever served β¦β¦.. military: No
Are you β¦β¦.. military: No
After that click on Save and Continue.
Parent 1 and 2: Choose any.
What is your current status?: Native USβ¦β¦
Primary spoken language: English
Do you wantβ¦β¦: No
After that click on Submit your completed application.
π¦ Part 3.
> After successfully completing the application put on your signature i.e your full name. Then you will be redirect to with all your detail. Under the student information you will get your username and temporary password. Note down that password, username and other details.
> After that you can go> if link not open try later then works because this anonymously https://bit.ly/38wwKJc and login where you will get your .edu email.
> NOTE: It will take more than 6hours for the login credentials to activate. So you will get error that your username and password is invalid
WRITTEN BY UNDER CODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
www.apply.vccs.edu
Apply to Virginia's Community Colleges - Sign In
College advice, college admission applications, pay for college, financial aid, scholarships, apply online for admission, online applications at Xap.
π¦ About X100 VERIFIED NORDVPN PREMIUM , send screanshoats to @UNDERCODE_TESTING
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦ Crack Evernote (Android version)-advanced account features
Refer to the previous article " Cracking Evernote (Android version)-password lock function ".
t.me/UndercodeTesting
π¦ Required tools:
1)java environment, the rationale for changing the apk
2) The rationale for changing the apk (Android decompilation-ApkIDE3.1):
3 ) The cracked apk (Android version)
> get from here https://t.me/UnderCodeTesting/1376
π¦ Two points need to be modified:
β Account type function
β‘Block the prompt of "Premium account has expired" in the notification bar
π¦ Modification process:
β Modify account type function
According to the modification in the previous article:
. \ smali \ com \ evernote \ ui \ EvernotePreferenceActivity.smali
among them,
raa () is equal to 1, that is, "NORMAL", ordinary users
this.h.ah (), the current user permissions,
From the. \ Smali \ com \ evernote \ d \ f \ r.smali file, you can get the permission relationship:
a = 1, "NORMAL"
b = 3, "PREMIUM"
c = 5, "VIP"
d = 7, "MANAGER"
e = 8, "SUPPORT"
f = 9, "ADMIN"
The ah () function exists in the. \ smali \ com \ evernote \ client \ b.smali file,
The ah () function code:
change into
Make the ah () function return value: 3, that is, "PREMIUM"
β‘ Block the prompt of "Premium account has expired" in the notification bar
The process of positioning and modifying the position,
1.
<string name = "premium_downgrade_title"> Premium account has expired </ string>
<string name = "premium_downgrade_text"> Renew premium account </ string>
2.
<public type = "string" name = "premium_downgrade_title" id = "0x7f0703ab" />
<public type = "string" name = "premium_downgrade_text" id = "0x7f0703ac" />
3- final step :
. \ smali \ com \ evernote \ util \ bz.smali
Add a line of code at the beginning of the function, return-void
EVERYNOTE CLICK HERE OFFICIAL SITE
ENJOY
WRITTEN BY UNDERCODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦ Crack Evernote (Android version)-advanced account features
Refer to the previous article " Cracking Evernote (Android version)-password lock function ".
t.me/UndercodeTesting
π¦ Required tools:
1)java environment, the rationale for changing the apk
2) The rationale for changing the apk (Android decompilation-ApkIDE3.1):
3 ) The cracked apk (Android version)
> get from here https://t.me/UnderCodeTesting/1376
π¦ Two points need to be modified:
β Account type function
β‘Block the prompt of "Premium account has expired" in the notification bar
π¦ Modification process:
β Modify account type function
According to the modification in the previous article:
. \ smali \ com \ evernote \ ui \ EvernotePreferenceActivity.smali
among them,
raa () is equal to 1, that is, "NORMAL", ordinary users
this.h.ah (), the current user permissions,
From the. \ Smali \ com \ evernote \ d \ f \ r.smali file, you can get the permission relationship:
a = 1, "NORMAL"
b = 3, "PREMIUM"
c = 5, "VIP"
d = 7, "MANAGER"
e = 8, "SUPPORT"
f = 9, "ADMIN"
The ah () function exists in the. \ smali \ com \ evernote \ client \ b.smali file,
The ah () function code:
change into
Make the ah () function return value: 3, that is, "PREMIUM"
β‘ Block the prompt of "Premium account has expired" in the notification bar
The process of positioning and modifying the position,
1.
<string name = "premium_downgrade_title"> Premium account has expired </ string>
<string name = "premium_downgrade_text"> Renew premium account </ string>
2.
<public type = "string" name = "premium_downgrade_title" id = "0x7f0703ab" />
<public type = "string" name = "premium_downgrade_text" id = "0x7f0703ac" />
3- final step :
. \ smali \ com \ evernote \ util \ bz.smali
Add a line of code at the beginning of the function, return-void
EVERYNOTE CLICK HERE OFFICIAL SITE
ENJOY
WRITTEN BY UNDERCODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦ Hackers stole 63.2GB of source code from Microsoft's private GitHub repository :
twitter.com/UndercodeNews
1) After announcing the successful invasion of Tokopedia, an Indonesian company, on March 28 this year, the hacker recently released heavy news that he had stolen .dump files with a capacity of more than 63.2GB from Microsoft's private GitHub repository. According to the screenshot of the file's directory listing, the dump file covers Azure, Office and some Windows runtimes.
2) This news was subsequently confirmed by the Twitter account of the data breach monitoring and prevention service organization Under the Breach. It should be noted that despite the large scale of the leaked source code, it does not mean that hackers will obtain Microsoft's core business secrets.
3) The content stored by Microsoft in the GitHub repository is generally public, even if it is stored in a private warehouse. The content is the same, and Microsoft will strictly screen the uploaded code to prevent leakage.
WRITTEN BY UNDERCODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
π¦ Hackers stole 63.2GB of source code from Microsoft's private GitHub repository :
twitter.com/UndercodeNews
1) After announcing the successful invasion of Tokopedia, an Indonesian company, on March 28 this year, the hacker recently released heavy news that he had stolen .dump files with a capacity of more than 63.2GB from Microsoft's private GitHub repository. According to the screenshot of the file's directory listing, the dump file covers Azure, Office and some Windows runtimes.
2) This news was subsequently confirmed by the Twitter account of the data breach monitoring and prevention service organization Under the Breach. It should be noted that despite the large scale of the leaked source code, it does not mean that hackers will obtain Microsoft's core business secrets.
3) The content stored by Microsoft in the GitHub repository is generally public, even if it is stored in a private warehouse. The content is the same, and Microsoft will strictly screen the uploaded code to prevent leakage.
WRITTEN BY UNDERCODE
β β β ο½ππ»βΊπ«Δπ¬πβ β β β
X (formerly Twitter)
UNDERCODE NEWS (@UndercodeNews) on X
π¦ Latest in Cyber & Tech News with AI-Powered Analysis and Fact Checking.
γjoin us: https://t.co/YVv330UsjQ
More: @DailyCve @UndercodeUpdate
γjoin us: https://t.co/YVv330UsjQ
More: @DailyCve @UndercodeUpdate