Speedup-example.cpp
/* Copyright (c) 2013, Regents of the Columbia University * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other * materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */#include <pthread.h>#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <assert.h>//#include "tern/user.h"#define N 4//#define M 30000#define M 30000*10//int nwait = 0;volatile long long sum;volatile long long sum_2;long loops = 6e3;pthread_mutex_t mutex;pthread_cond_t cond;pthread_barrier_t bar;void set_affinity(int core_id) { cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(core_id, &cpuset); assert(pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset) == 0);}void* thread_func(void *arg) { set_affinity((int)(long)arg); for (int j = 0; j < M; j++) { //pthread_mutex_lock(&mutex); //nwait++; for (long i = 0; i < loops; i++) // This is the key of speedup for parrot: the mutex needs to be a little bit congested. { sum += i;sum_2 += i; } //pthread_cond_wait(&cond, &mutex); //printf("being in the lock is: %lu\n", pthread_self()); //pthread_mutex_unlock(&mutex); //soba_wait(0); //pthread_barrier_wait(&bar); for (long i = 0; i < loops; i++) {sum += i*i*i*i*i*i; } //fprintf(stderr, "compute thread %u %d\n", (unsigned)thread, sched_getcpu()); }}int main(int argc, char *argv[]) { set_affinity(23); //soba_init(0, N, 20); pthread_t th[N]; int ret; //pthread_cond_init(&cond, NULL); //pthread_barrier_init(&bar, NULL, N); for(unsigned i=0; i<N; ++i) { ret = pthread_create(&th[i], NULL, thread_func, (void*)i); assert(!ret && "pthread_create() failed!"); } /*for (int j = 0; j < M; j++) { while (nwait < N) { sched_yield(); } pthread_mutex_lock(&mutex); nwait = 0; //fprintf(stderr, "broadcast %u %d\n", (unsigned)pthread_self(), sched_getcpu()); pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mutex); } */ for(unsigned i=0; i<N; ++i) pthread_join(th[i], NULL); // test the validity of results printf("sum_2 = %lld\n", sum_2); //printf("sum = %lld\n", sum); exit(0);}
The above is the route of our entire journey, and below is the origin of our journey.
Xtern/lib/runtime/record-scheduler.cpp
void RRScheduler::getTurn(){ int tid = self(); assert(tid>=0 && tid < Scheduler::nthread); waits[tid].wait(); dprintf("RRScheduler: %d gets turn\n", self()); SELFCHECK;}
/// tern tid for current thread static int self() { return self_tid; }
Rrschedturn: getturn is the unique entry of rrschedit: wait_t: Wait.
Getturn is used to run a thread while waiting for other threads to achieve serialization.
In fact, getturn is first seen in struct serializer, So here comes the inheritance relationship of some important classes.
Next, we need to understand where getturn is called and Its Role in RR scheduling.
There are five direct calls to getturn () in 34 times:
While the functions that call sched_timer_start have (both in xtern/lib/runtime/record-runtime.cpp ):
(B) Use tern_pthread_create to create four subthreads.
In the third round, let's explore what tern_pthread_create has done.
Third time
The last time we talked about it, we met the first strong competitor, "two orders". In the first confrontation, he made a big move: "Use tern_pthread_create to create subthreads ". Next, let's take a look at how we break it.
This is the principle decomposition diagram of the big moves. When recorderrt <_ S>: pthreadcreate is analyzed, a prompt is displayed:
/// The pthread_create wrapper solves three problems.////// Problem 1. We must assign a logical tern tid to the new thread while/// holding turn, or multiple newly created thread could get their logical/// tids nondeterministically. To do so, we assign a logical tid to a new/// thread in the thread that creates the new thread.////// If we were to assign this logical id in the new thread itself, we may/// run into nondeterministic runs, as illustrated by the following/// example////// t0 t1 t2 t3/// getTurn();/// create t2/// putTurn();/// getTurn();/// create t3/// putTurn();/// getTurn();/// get turn tid 2/// putTurn();/// getTurn();/// get turn tid 3/// putTurn();////// in a different run, t1 may run first and get turn tid 2.////// Problem 2. When a child thread is created, the child thread may run/// into a getTurn() before the parent thread has assigned a logical tid/// to the child thread. This causes getTurn to refer to self_tid, which/// is undefined. To solve this problem, we use @thread_begin_sem to/// create a thread in suspended mode, until the parent thread has/// assigned a logical tid for the child thread.////// Problem 3. We can use one semaphore to create a child thread/// suspended. However, when there are two pthread_create() calls, we may/// still run into cases where a child thread tries to get its/// thread-local tid but gets -1. consider////// t0 t1 t2 t3/// getTurn();/// create t2/// sem_post(&thread_begin_sem)/// putTurn();/// getTurn();/// create t3/// sem_wait(&thread_begin_sem);/// self_tid = TidMap[pthread_self()]/// sem_post(&thread_begin_sem)/// putTurn();/// getTurn();/// get turn tid 2/// putTurn();/// sem_wait(&thread_begin_sem);/// self_tid = TidMap[pthread_self()]/// getTurn();/// get turn tid 3/// putTurn();////// The crux of the problem is that multiple sem_post can pair up with/// multiple sem_down in different ways. We solve this problem using/// another semaphore, thread_begin_done_sem.///
It seems to be a good sword.
It is still difficult to understand the number of decomposition charts and some of the musical scores. Let's take a look at the news from our partner's top chefs:
Scenario 1:./speedup-example (mutex has four sub-threads, M = 30000*10, and parrot is not used)
Scenario 2:./run_example_tern (with mutex, four sub-threads, M = 30000*10, using parrot)
Scenario 3:./run_example_tern (no mutex, four sub-threads, M = 30000*10, use parrot)
Through top, we found that --
This allows us to explore the order in which four subthreads are created under scenario 2 and scenario 3. Imagine first: Scenario 2 is that four subthreads are almost created at the same time, and scenario 2 is to create two subthreads at the same time at the beginning, then, each time a subthread finishes its own task, it creates a new subthread.
Scenario 4:./run_example_tern (there are mutex, eight sub-threads, M = 30000*10, use parrot)
Scenario 5:./run_example_tern (no mutex, eight sub-threads, M = 30000*10, use parrot)
One piece for parrot source code analysis
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
