Разработка лабораторного практикума по курсу "Методы параллельной обработки"
Характеристика основных моделей параллельных вычислений. Основные директивы и функции, применяемые в наиболее распространенных технологиях параллельного программирования. Функциональные требования к программе, реализующей лабораторный практикум.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | дипломная работа |
| Язык | русский |
| Дата добавления | 17.06.2013 |
| Размер файла | 3,1 M |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Microsoft Visual Studio 2008предъявляет следующие системные требования:
· Компьютер с процессором с тактовой частотой не менее 1,6 ГГц
· Visual Studio 2008 можно установить на следующие операционные системы:
o Windows Vista (x86 и x64) - все выпуски, кроме Starter Edition
o Windows XP (x86 и x64) с пакетом обновления 2 или более поздней версии - все выпуски, кроме Starter Edition
o Windows Server 2003 (x86 и x64) с пакетом обновления 1 или более поздней версии (все выпуски)
o Windows Server 2003 R2 (x86 и x64) или более поздней версии (все выпуски)
· ОЗУ не менее 384 МБ (ОЗУ не менее 768 МБ для Windows Vista)
· 2,2 ГБ свободного дискового пространства
· Жесткий диск 5400 об/мин
· Дисплей с разрешением не менее 1024х768
· Дисковод DVD-ROM
Для того чтобы использовать Visual Studio 2008 в работе с лабораторным практикумом, требуется подключить библиотеки параллельного программирования: MPI, OpenMP, Posix Threads. О том, как это сделать, подробно написано в источниках [11], [12] и [13].
Таким образом, для реализации лабораторного практикума необходимо:
Разработать методику проведения лабораторных работ.
Разработать варианты заданий к лабораторному практикуму.
Разработать программу, реализующую лабораторный практикум.
Протестировать и отладить лабораторные работы практикума.
2.2 Проведение лабораторных работ
Лабораторные работы проводятся в следующем порядке:
1. Выполнение домашнего задания, включающего:
Изучение студентом теоретических основ технологий MPI, OpenMP и Posix Threads.
Изучение работы в среде разработки.
Составление последовательной программы согласно полученному варианту задания.
Составление параллельных программ на основе последовательной.
2. Работа в дисплейном классе, включающая:
Прохождение вступительного теста в программе, реализующей лабораторный практикум.
Загрузка решений в программу, реализующую лабораторный практикум.
Построение зависимостей времени выполнения программы и занимаемой оперативной памяти от параметров программы для каждой технологии параллельного программирования и последовательной программы.
3. Написание отчета, включающего выводы об оптимальной технологии для решения поставленной задачи и параметрах этой технологии.
Учебные задания
В программу, реализующую лабораторную работу, можно вносить любые задания на программирование с применением библиотек MPI, OpenMP и Posix Threads. Предполагается, что это будут задания, которые можно разработать изменением готовой последовательной программы. Примеры предполагаемых заданий приведены в Приложении 2.
Подготовка к выполнению
Для подготовки к выполнению лабораторных работ необходимо:
· Изучить теоретический материал по библиотекам MPI, OpenMP и Posix Threads.
· Изучить особенности работы в среде программирования.
· Составить последовательную программу согласно полученному варианту задания. Варианты домашних заданий приведены в Приложении 2.
· На основе последовательной программы составить варианты параллельных программ. Там, где это возможно, следует разработать несколько вариантов параллельной программы в рамках одной технологии параллельного программировния (например, для Posix Threads можно представить решения с использованием мьютексов и без).
Выполнение лабораторных работ
Работы выполняются с использованием среды разработки и программы, реализующей лабораторный практикум.
Для выполнения работ необходимо:
1) Зайти в программу, реализующую практикум, под своей учетной записью.
2) Успешно пройти вступительный тест.
3) Загрузить код последовательной и трех параллельных программ, разработанных дома, в соответствующие вкладки программы, реализующей практикум.
4) Для последовательной программы снять зависимости времени выполнения и объема оперативной памяти, занимаемой программой, от размерности программы.
5) Для параллельных программ снять зависимости времени выполнения и объема оперативной памяти, занимаемой программой, от размерности программы и числа запущенных параллельных процессов (потоков). Если разработано несколько вариантов программы в рамках одной технологии, то следует выбрать оптимальный вариант и обосновать свой выбор.
6) По полученным зависимостям сделать вывод об оптимальной технологии для решения данной задачи, оптимальном количестве запущенных параллельных процессов (потоков) и оптимальной размерности задачи для достижения заданной точности вычислений (в тех вариантах, где размерность влияет на точность).
Для сдачи лабораторных работ необходимо иметь отчеты, включающие коды последовательной и параллельных программ согласно варианту, зависимости, описанные в задании и выводы по результатам этих зависимостей.
2.3 Алгоритмическое обеспечение
Прежде чем студенты смогут выполнять лабораторные работы, лабораторный практикум должен быть подготовлен к работе. Для этого администратор системы должен авторизоваться, занести в программу справочную информацию по технологиям параллельного программирования и заполнить таблицу вариантов с подробным описанием варианта и указанием имен программных переменных. Затем администратор должен заполнить таблицу пользователей с указанием варианта, присвоенного пользователю. Затем администратор должен заполнить банк вопросов предварительного тестирования, введя в программу вопросы и ответы к ним, указав правильный ответ (ответы), для каждой из технологий параллельного программирования. В случае, если администратора устраивают существующие варианты, справочные данные, вопросы предварительного тестирования и списки студентов, уже существующие в программе, данный этап может быть пропущен.
Алгоритм работы администратора с программным обеспечением, реализующим лабораторный практикум, представлен на рис.6.
Рис.6. Алгоритм работы администратора с программой
Студент должен авторизоваться, ответить на вопросы вступительного тестирования, получить вердикт программы о том, допущен он до выполнения лабораторных работ или нет. В случае допуска студент должен ввести в систему последовательную программу, разработанную дома, и варьируя программные переменные, снять две зависимости - зависимость времени выполнения от размерности задачи и использованной оперативной памяти от размерности задачи. На соответствующей вкладке студент вводит программу с использованием MPI в систему. Варьируя программные переменные, он должен снять четыре зависимости - времени выполнения и использованной оперативной памяти от размерности задачи, времени выполнения и использованной оперативной памяти от числа параллельных процессов (потоков). Затем вводятся программы с использованием OpenMP и Posix Threads, по ним также снимаются четыре зависимости.
Алгоритм работы студента с программным обеспечением, реализующим лабораторный практикум, представлен на рис.7.
Рис.7. Алгоритм работы студента с программой
В алгоритм заложено различие действий при обращении с программой преподавателя и студента, авторизация доступа, функции добавления пользователей, вариантов, вопросов теста, справочных данных, компиляции программ, изменения переменных внутри разработанных программ и построения зависимостей.
Структура разработанного алгоритма удовлетворяет функциональным требованиям к программе, изложенным в предыдущем разделе.
Схематичный алгоритм работы программы представлен на рис.8.
Рис.8. Алгоритм работы программы
В данной схеме представлены реакции программы на действия пользователей - администратора и студента. Описаны основные результаты возможных действий, порядок возникновения и закрытия элементов интерфейса, основные функции, выполняемые программой.
2.4 Функциональная структура программы лабораторного практикума
Функциональная структура программы представлена на рис.9.
Рис.9. Функциональная структура программы
В структуре программы можно выделить следующие функциональные части:
Project1. cpp - модуль, инициализирующий модули Unit1…Unit11.
Database - база данных программы.
Unit1 - главное окно программы, которое содержит рабочие области студента и администратора, а также построение графиков и компиляцию написанных студентом программ.
Unit2 - авторизация пользователей.
Unit3 - добавление нового пользователя.
Unit4 - редактирование учетной записи пользователя.
Unit5 - добавление варианта учебных заданий.
Unit6 - добавление вопросов и ответов в предварительный тест.
Unit7 - редактирование варианта учебных заданий.
Unit8 - предоставление студенту вопросов, проверка правильности ответов и подсчет результатов.
Unit9 - редактирование содержимого тестов.
Unit10 - настройка программы.
Unit11 - добавление ответов в вопросы предварительного теста.
В модуле Project1. cpp происходит создание всех форм программы как для администратора, так и для администратора.
Таблица auth (таблица пользователей) имеет поля id, login, password, variant и superuser, где id - идентификатор пользователя, login - учетная запись пользователя, password - пароль пользователя, variant - учебный вариант, закрепленный за пользователем, superuser - логическое поле, для администратора оно имеет значение "True". Для администратора атрибут "variant" остается пустым.
Таблица files (таблица справочных файлов) имеет поля kod, filepath и info, где kod - идентификатор справочного файла, filepath - путь к справочному файлу, info - технология, к которой относится справочный файл.
Таблица variant (таблица учебных вариантов) имеет поля nomervariant, namevariant, filepath, perpot и perraz, где nomervariant - номер учебного варианта, namevariant - название варианта, filepath - путь к файлу варианта, perpot - имя переменной числа процессов (потоков), perraz - имя переменной размерности.
Таблицы vopros (таблица вопросов и ответов вступительного теста) имеет поля id, kat, tekst, var и bool, где id - номер ответа, kat - название технологии, к которой относится вопрос, tekst - непосредственно вопрос, var - текст ответа и bool - логическое поле, для правильного ответа оно имеет значение "True".
В модуле Unit1. cpp содержатся интерфейсы главных форм студента и администратора, а также средства компиляции программ, написанных студентами, с нахождением времени выполнения программы, оперативной памяти, занимаемой программой, построением зависимостей времени и памяти от параметров программ.
В модуле Unit2. cpp содержится функция авторизации пользователей. Пользователю предлагается ввести учетную запись и пароль. В зависимости от учетной записи откроется интерфейс студента или администратора.
В модуле Unit3. cpp содержится функция добавления новых пользователей. При добавлении пользователя с ролью "Студент", добавляемому пользователю присваивается учебный вариант.
В модуле Unit4. cpp содержится функция редактирования записи пользователя. Также присутствует возможность удаления записи.
В модуле Unit5. cpp содержится функция добавления нового учебного варианта. Присутствует возможность загрузки файла с текстовым описанием варианта и системных переменных для данного варианта.
В модуле Unit6. cpp содержится функция добавления вопросов и ответов в предварительный тест. Каждый вопрос может иметь несколько правильных ответов.
В модуле Unit7. cpp содержится функция редактирования вариантов учебных заданий. Можно изменять название, описание и системные переменные для выбранного варианта.
В модуле Unit8. cpp содержатся функции проведения предварительного теста у студента. Случайным образом выбирается 9 вопросов. При ответе на 6 или более вопросов студент считается допущенным к выполнению лабораторных работ.
В модуле Unit9. cpp содержится функция редактирования вопросов. Реализована возможность добавлять, удалять и назначать правильными ответы на вопросы. Также можно редактировать текст самого вопроса.
В модуле Unit10. cpp содержатся функции настройки программы, а именно ip-адрес сервера и путь к базе данных на сервере.
В модуле Unit11. cpp содержится функция вставки записи о вопросе в таблицу базы данных vopros.
2.5 Интерфейс разработанной программы
По функциональной структуре, изложенной в п.2.4, была разработана программа, реализующая лабораторный практикум. Листинг программы приведен в Приложении 1. Ниже представлен пример работы с разработанной программой для администратора и студента. Делается допущение, что ярлык приложения располагается на Рабочем Столе.
Работа с программой (преподаватель)
На Рабочем Столе выбрать ярлык Parallel и дважды щелкнуть по нему. Появится форма входа в систему
После введения логина и пароля администратор попадает на главную форму работы с программой
Далее администратор может просматривать и загружать справочные материалы. См. пункт "Содержимое справки".
Редактировать и удалять существующие варианты заданий и добавлять новые с указанием названий переменных числа потоков и размерности
Редактировать и удалять существующие записи пользователей и добавлять новые с указанием присваиваемого учебного варианта
Просматривать список действий пользователей и при необходимости очищать его.
Редактировать и удалять существующие вопросы предварительного теста и добавлять новые с привязкой к конкретной технологии параллельного программирования
Задавать настройки программы, такие как IP-адрес сервера и путь к базе данных на сервере.
Работа с программой (студент)
На Рабочем Столе выбрать ярлык Parallel и дважды щелкнуть по нему. Появится форма входа в систему (рис. 11). После введения логина и пароля студент попадает в форму предварительного теста (рис. 17).
Рис. 17. Вопрос предварительного теста
После прохождения теста студент получает вердикт о допуске/недопуске его к работам лабораторного практикума (рис. 18).
Рис. 18. Вердикт программы о допуске/недопуске
После допуска студент попадает на главную форму работы с программой (рис. 19).
Рис. 19. Главная форма работы студента с программой
Для последовательной программы студент меняет размерность вычислений и снимает две зависимости - времени выполнения от размерности и использования оперативной памяти от размерности (рис. 20).
Рис. 20. Окно последовательной программы
Для параллельных программ студент меняет размерность вычислений и количество параллельных процессов (потоков). По полученным значениям студент снимает четыре зависимости - времени выполнения от размерности, использования оперативной памяти от размерности, времени выполнения от числа процессов (потоков), использования оперативной памяти от числа процессов (потоков). Этот пример представлен на рис. 21.
Рис. 21. Окно параллельной программы
2.6 Тестирование и отладка
Методика тестирования заключалась в том, что сначала была проверена правильность реакции программы на действия администратора, а затем студента.
Для этого была пройдена авторизация под учетной записью администратора, в программу была занесена справочная информация по технологиям параллельного программирования и заполнена таблица вариантов с подробным описанием варианта и указанием имен программных переменных. Затем была заполнена таблица пользователей с указанием варианта, присвоенного пользователю. Затем был заполнен банк вопросов предварительного тестирования, для каждой из технологий параллельного программирования в программу введены вопросы и ответы к ним, указан правильный ответ (ответы). В процессе проведения вышеописанных действий ошибок не выявлено.
Была пройдена авторизация под студентом, пройдены варианты успешного и неуспешного выполнения студентом предварительного теста. Проверена корректность просмотра варианта задания и справочной информации. Затем в систему были занесены разработанные программы. Программы были разработаны согласно заданию, изложенному в варианте 1 Приложения 2.
Были разработаны следующие решения:
Последовательное решение.
#include <iostream>
#include <iomanip>
#include <cmath>
int main (int argc, char** argv)
{
const unsigned long cntSteps=500000000; /* # of rectangles */
double step;
const double PI25DT = 3.141592653589793238462643; // reference Pi value
double pi=0;
double sum=0.0;
double x;
std:: cout<< "calculating pi on CPU single-threaded\n";
step = 1. /static_cast<double> (cntSteps);
for (unsigned long i=0; i<cntSteps; i++)
{
x = (i +.5) *step;
sum = sum + 4.0/ (1. + x*x);
}
pi = sum*step;
std:: cout << "The value of PI is " << pi << " Error is " << fabs (pi - PI25DT) << "\n";
return 0;
}
Решение с применением MPI.
#include <iostream>
#include <cmath>
#include <mpi. h>
int main (int argc, char* argv [])
{
int idCurrentThread, cntThreads;
int lenNameProcessor;
char nameProcessor [MPI_MAX_PROCESSOR_NAME];
double localPi, step, sum, x;
double PI25DT = 3.141592653589793238462643;
long cntSteps = 500000000;
MPI:: Init (argc,argv);
cntThreads = MPI:: COMM_WORLD. Get_size ();
idCurrentThread = MPI:: COMM_WORLD. Get_rank ();
MPI:: Get_processor_name (nameProcessor,lenNameProcessor);
std:: cout << "Process " << idCurrentThread << " of " << cntThreads << " is on " <<nameProcessor << std:: endl;
step = 1. /static_cast<double> (cntSteps);
sum = 0.0;
long cntStepsPerThread= cntSteps / cntThreads;
long limitRightCurrentThread = (idCurrentThread+1) *cntStepsPerThread;
// std:: cout << "limitLeftCurrentThread" << idCurrentThread*cntStepsPerThread << std:: endl;
// std:: cout << "limitRightCurrentThread" << limitRightCurrentThread << std:: endl;
for (long i = idCurrentThread*cntStepsPerThread; i < limitRightCurrentThread; i ++)
{
x = step * (i + 0.5);
sum = sum + 4.0/ (1.0 + x*x);
}
localPi = step * sum;
double pi=0.;
MPI:: COMM_WORLD. Reduce (&localPi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0);
if (idCurrentThread == 0)
{
std:: cout << "The value of PI is " << pi << " Error is " << fabs (pi - PI25DT) << std:: endl;
}
MPI:: Finalize ();
return 0;
}
Решение с применением OpenMP.
#include <iostream>
#include <iomanip>
#include <cmath>
#include <omp. h>
int main (int argc, char** argv)
{
const unsigned long numSteps=500000000; /* default # of rectangles */
double step;
double PI25DT = 3.141592653589793238462643;
double pi=0;
double sum=0.0;
double x;
#pragma omp parallel
{
#pragma omp master
{
int cntThreads=omp_get_num_threads ();
std:: cout<<"OpenMP. number of threads = "<<cntThreads<<std:: endl;
}
}
step = 1. /static_cast<double> (numSteps);
#pragma omp parallel for private (x), reduction (+: sum)
for (int i=0; i<numSteps; i++)
{
x = (i +.5) *step;
sum = sum + 4.0/ (1. + x*x);
}
pi = sum*step;
std:: cout << "The value of PI is " << pi << " Error is " << fabs (pi - PI25DT) << std:: endl;
return 0;
}
Решение с применением Posix Threads.
#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <pthread. h>
#define cntThreads 4
struct ArgsThread
{
long long left,right;
double step;
double partialSum;
};
static void *worker (void *ptrArgs)
{
ArgsThread * args = reinterpret_cast<ArgsThread *> (ptrArgs);
double x;
double sum=0.;
double step=args->step;
for (long long i=args->left; i<args->right; i++)
{
x = (i +.5) *step;
sum = sum + 4.0/ (1. + x*x);
}
args->partialSum=sum*step;
return NULL;
}
int main (int argc, char** argv)
{
const unsigned long num_steps=500000000;
const double PI25DT = 3.141592653589793238462643;
pthread_t threads [cntThreads];
ArgsThread arrArgsThread [cntThreads];
std:: cout<<"POSIX threads. number of threads = "<<cntThreads<<std:: endl;
double step = 1. / (double) num_steps;
long long cntStepsPerThread= num_steps / cntThreads;
for (unsigned int idThread=0; idThread<cntThreads; idThread++)
{
arrArgsThread [idThread]. left = idThread*cntStepsPerThread;
arrArgsThread [idThread]. right = (idThread+1) *cntStepsPerThread;
arrArgsThread [idThread]. step = step;
if (pthread_create (&threads [idThread], NULL, worker, &arrArgsThread [idThread])! = 0)
{
return EXIT_FAILURE;
}
}
double pi=0.;
for (unsigned int idThread=0; idThread<cntThreads; idThread++)
{
if (pthread_join (threads [idThread], NULL)! = 0)
{
return EXIT_FAILURE;
}
pi +=arrArgsThread [idThread]. partialSum;
}
std:: cout << "The value of PI is " << pi << " Error is " << fabs (pi - PI25DT) << std:: endl;
return 0;
}
Данные решения были занесены в систему и путем изменения параметров получены следующие зависимости:
Для последовательной программы (рис. 22)
Рис. 22. Полученные зависимости последовательной программы
Для программы с использованием MPI (рис. 23)
Рис. 23. Полученные зависимости программы с использованием MPI
Для программы с использованием OpenMP (рис.24)
Рис. 24. Полученные зависимости программы с использованием OpenMP
Для программы с использованием Posix Threads (рис.25)
Рис. 25. Полученные зависимости программы с использованием Posix Threads
Полученные зависимости совпадают с теоретически ожидаемыми с поправкой на случайные отклонения, которые могут возникать при работе параллельных программ. Результаты тестирования показали, что программа работает верно.
2.7 Выводы
В данном разделе выбраны программные средства, реализующие лабораторную работу. Это среда разработки, поддерживающая разработку, компиляцию и исполнение программ, использующих технологии параллельного программирования MPI, OpenMP и Posix Threads, и разрабатываемое в рамках данного дипломного проекта программное обеспечение, позволяющее реализовать лабораторный практикум. Также было разработано методическое обеспечение лабораторного практикума, а именно учебные задания, методика подготовки и выполнения лабораторных работ, входящих в практикум, варианты домашних заданий. По методике выполнения лабораторного практикума были сформулированы функциональные требования к программе, реализующей практикум. Исходя из этих требований, было разработано алгоритмическое обеспечение, составлена функциональная структура разрабатываемой программы, разработано программное обеспечение, после чего произведено тестирование и отладка разработанного программного обеспечения.
Заключение
Задачей данного дипломного проекта была разработка лабораторного практикума по курсу "Методы параллельной обработки". В качестве изучаемых технологий были выбраны MPI, OpenMP и Posix Threads. Данные технологии охватывают все основные классы современных параллельных компьютеров, такие как массивно-параллельные системы, симметричные мультипроцессорные системы, системы с неоднородным доступом к памяти и кластерные системы. В рамках дипломного проекта составлена методика проведения лабораторных работ, разработаны задания для учащихся. Исходя из методики проведения лабораторных работ, были составлены функциональные требования. Разработано алгоритмическое обеспечение лабораторного практикума, выбраны инструментальные средства разработки и проведения лабораторной работы, разработана функциональная структура программы, по которой разработано программное обеспечение для проведения лабораторных работ, проведено тестирование и отладка программного обеспечения.
Выполнив лабораторные работы, студент будет иметь представление о технологиях параллельного программирования MPI, OpenMP и Posix Threads, знать об основных директивах и функциях, применяемых в вышеуказанных технологиях, а также сможет оценить зависимость времени выполнения программы и занимаемой программой оперативной памяти от числа параллельных процессов (потоков) и размерности вычислений. После этого, проанализировав полученные зависимости, студент сможет сделать вывод о наиболее целесообразной технологии для решения поставленной задачи, где критическим ресурсом может являться как время выполнения, так и оперативная память.
После выполнения данной лабораторной работы студент сможет самостоятельно создавать несложные приложения с использованием любой параллельной технологии из вышеперечисленных.
Пробные лабораторные работы были проведены в мае 2013 года с привлечением технических средств кафедры. Стендовый доклад о лабораторных работах, связанных с технологиями параллельного программирования, был представлен на Научной Сессии НИЯУ МИФИ 2013.
Объем разработанного программного обеспечения составил 22,7 Мбайт.
Список литературы
1. Гергель В.П. Высокопроизводительные вычисления для многоядерных многопроцессорных систем. Издательство нижегородского госуниверситета, 2010.
2. Developing Parallel Programs - A Discussion of Popular Models. An Oracle White Paper, September 2010.
3. http://parallel.ru/computers/classes.html. Основные классы современных параллельных компьютеров.
4. MPI: A Message-Passing Interface Standard Version 3.0. Message Passing Interface Forum, September 21, 2012.
5. http://www.mpi-forum.org/. Описание стандарта MPI.
6. Немнюгин С., Стесик О. Параллельное программирование для многопроцессорных вычислительных систем. СПБ БХВ - Петербург, 2002.
7. Левин М.П. // Параллельное программирование с использованием OpenMP: учебное пособие. 2012. С.10.
8. http://openmp.org/wp/ Описание стандартов OpenMP.
9. Иртегов Д. Многопоточное программирование с использованием POSIX Threads. Интуит, 2010.
10. http://www.dreamspark.ru/ программа Microsoft DreamSpark.
11. http://iproc.ru/drafts/microsoft-mpi/ установка MPI на Visual Studio 2008.
12. http://iproc.ru/programming/openmp-visual-studio/ установка OpenMP на Visual Studio 2008.
13. http://www.sourceware.org/pthreads-win32/ библиотека Posix Threads для Windows.
Приложения
Приложение 1. Код программы лабораторного практикума
Модуль Project1. cpp
// ---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
// ---------------------------------------------------------------------------
USEFORM ("Unit1. cpp", Form1);
USEFORM ("Unit2. cpp", Auth);
USEFORM ("Unit3. cpp", User);
USEFORM ("Unit4. cpp", ReUser);
USEFORM ("Unit5. cpp", Varianty);
USEFORM ("Unit6. cpp", Vopros);
USEFORM ("Unit7. cpp", ReVarianty);
USEFORM ("Unit8. cpp", Test);
USEFORM ("Unit9. cpp", ReVopros);
USEFORM ("Unit10. cpp", Options);
USEFORM ("Unit11. cpp", addotvet);
// ---------------------------------------------------------------------------
WINAPI WinMain (HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
Application->Initialize ();
Application->Title = "Методы параллельной обработки";
Application->CreateForm (__classid (TForm1), &Form1);
Application->CreateForm (__classid (TAuth), &Auth);
Application->CreateForm (__classid (TUser), &User);
Application->CreateForm (__classid (TReUser), &ReUser);
Application->CreateForm (__classid (TVarianty), &Varianty);
Application->CreateForm (__classid (TVopros), &Vopros);
Application->CreateForm (__classid (TReVarianty), &ReVarianty);
Application->CreateForm (__classid (TTest), &Test);
Application->CreateForm (__classid (TReVopros), &ReVopros);
Application->CreateForm (__classid (TOptions), &Options);
Application->CreateForm (__classid (Taddotvet), &addotvet);
Application->Run ();
}
catch (Exception &exception)
{
Application->ShowException (&exception);
}
catch (.)
{
try
{
throw Exception ("");
}
catch (Exception &exception)
{
Application->ShowException (&exception);
}
}
return 0;
}
// ---------------------------------------------------------------------------
Модуль Unit1. cpp
// ---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
#include "Unit1. h"
#include "Unit2. h"
#include "Unit3. h"
#include "Unit4. h"
#include "Unit5. h"
#include "Unit6. h"
#include "Unit7. h"
#include "Unit9. h"
#include "Unit10. h"
#include <IniFiles. hpp>
// ---------------------------------------------------------------------------
#pragma package (smart_init)
#pragma link "CSPIN"
#pragma resource "*. dfm"
#define logg StringGrid1->RowCount++; StringGrid1->Cols [0] - >Add (Date (). DateString ()); StringGrid1->Cols [1] - >Add
TForm1 *Form1;
AnsiString path = ExtractFilePath (Application->ExeName);
TIniFile *Ini = new TIniFile (path+"\\options. ini");
// ---------------------------------------------------------------------------
__fastcall TForm1:: TForm1 (TComponent* Owner)
: TForm (Owner)
{
StringGrid1->ColWidths [0] = 75;
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Create_Update (String &wh)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='"+wh+"'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="update files set filepath='"+OpenDialog1->FileName+"', info='"+wh+"' where info='"+wh+"'";
ADOQuery0->ExecSQL ();
}
else
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="insert into files (filepath, info) values ('"+OpenDialog1->FileName+"','"+wh+"')";
ADOQuery0->ExecSQL ();
}
}
void __fastcall TForm1:: Button1Click (TObject *Sender)
{
if (OpenDialog1->Execute ())
{
Create_Update ("MPI"); // Создаём или обновляем путь к файлу
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='MPI'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button2->Enabled=true; CheckBox1->Visible=true; } else {Button2->Enabled=false; CheckBox1->Visible=false; }
}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button3Click (TObject *Sender)
{
if (OpenDialog1->Execute ())
{
Create_Update ("OpenMP");
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='OpenMP'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button4->Enabled=true; CheckBox2->Visible=true; } else {Button4->Enabled=false; CheckBox2->Visible=false; }
}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button5Click (TObject *Sender)
{
if (OpenDialog1->Execute ())
{
Create_Update ("Posix Threads");
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='Posix Threads'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button6->Enabled=true; CheckBox3->Visible=true; } else {Button6->Enabled=false; CheckBox3->Visible=false; }
}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormActivate (TObject *Sender)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='MPI'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button2->Enabled=true; CheckBox1->Visible=true; } else {Button2->Enabled=false; CheckBox1->Visible=false; }
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='OpenMP'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button4->Enabled=true; CheckBox2->Visible=true; } else {Button4->Enabled=false; CheckBox2->Visible=false; }
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='Posix Threads'";
ADOQuery0->Open ();
if (ADOQuery0->RecordCount! =0)
if (FileExists (ADOQuery0->FieldByName ("FilePath") - >AsString)) {Button6->Enabled=true; CheckBox3->Visible=true; } else {Button6->Enabled=false; CheckBox3->Visible=false; }
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormCreate (TObject *Sender)
{
ShowWindow (Application->Handle, SW_HIDE); // Скрываем окно
if (FileExists (Ini->ReadString ("NetWork","FilePathDB",". /db/1. accdb"))) // Если файл существует
{
ADOConnection1->Connected=false;
ADOConnection1->ConnectionString="Provider=Microsoft. ACE. OLEDB.12.0; Data Source="+Ini->ReadString ("NetWork","FilePathDB",". /db/1. accdb") +"; Jet OLEDB: Database Password=murlokotam; ";
ADOConnection1->Connected=true;
}
else
{
MessageBox (0,"Файл базы данных не найден (Файл 1. accdb)","Ошибка",MB_OK+MB_ICONERROR);
if (OpenDialog1->Execute ())
{
Ini->WriteString ("NetWork","FilePathDB",OpenDialog1->FileName);
}
FormCreate (Sender);
}
Client1->Close ();
Client1->Address=Ini->ReadString ("NetWork","IPAdress","192.168.1.1");
Client1->Open ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button2Click (TObject *Sender)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='MPI'";
ADOQuery0->Open ();
ShellExecute (Handle, "open", ADOQuery0->FieldByName ("FilePath") - >AsString. c_str (), 0, 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button4Click (TObject *Sender)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='OpenMP'";
ADOQuery0->Open ();
ShellExecute (Handle, "open", ADOQuery0->FieldByName ("FilePath") - >AsString. c_str (), 0, 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button6Click (TObject *Sender)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select filepath from files where info='Posix Threads'";
ADOQuery0->Open ();
ShellExecute (Handle, "open", ADOQuery0->FieldByName ("FilePath") - >AsString. c_str (), 0, 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormShow (TObject *Sender)
{
Auth->ShowModal ();
ADOQuery1->Close ();
ADOQuery1->SQL->Clear ();
ADOQuery1->SQL->Text="select * from auth";
ADOQuery1->Open ();
ADOQuery1->FieldByName ("login") - >DisplayLabel="Логин";
ADOQuery1->FieldByName ("password") - >DisplayLabel="Пароль";
ADOQuery1->FieldByName ("variant") - >DisplayLabel="Вариант";
ADOQuery1->FieldByName ("variant") - >DisplayWidth=10;
DBGrid1->Columns->Items [0] - >Visible=false;
ADOQuery3->Close ();
ADOQuery3->SQL->Clear ();
ADOQuery3->SQL->Text="select * from variant";
ADOQuery3->Open ();
ADOQuery3->FieldByName ("nomervariant") - >DisplayLabel="Номер варианта";
ADOQuery3->FieldByName ("namevariant") - >DisplayLabel="Наименование варианта";
ADOQuery3->FieldByName ("namevariant") - >DisplayWidth=40;
DBGrid3->Columns->Items [2] - >Visible=false;
DBGrid3->Columns->Items [3] - >Visible=false;
DBGrid3->Columns->Items [4] - >Visible=false;
ADOQuery11->Close ();
ADOQuery11->SQL->Clear ();
ADOQuery11->SQL->Text="select distinct tekst from vopros where kat='MPI'";
ADOQuery11->Open ();
ADOQuery11->FieldByName ("tekst") - >DisplayLabel="Вопрос";
ADOQuery12->Close ();
ADOQuery12->SQL->Clear ();
ADOQuery12->SQL->Text="select distinct tekst from vopros where kat='OpenMP'";
ADOQuery12->Open ();
ADOQuery12->FieldByName ("tekst") - >DisplayLabel="Вопрос";
ADOQuery13->Close ();
ADOQuery13->SQL->Clear ();
ADOQuery13->SQL->Text="select distinct tekst from vopros where kat='Posix Threads'";
ADOQuery13->Open ();
ADOQuery13->FieldByName ("tekst") - >DisplayLabel="Вопрос";
Memo111->Lines->SaveToFile (path+"\db\\run\\1. txt");
Memo112->Lines->SaveToFile (path+"\db\\run\\2. txt");
// Series1->AddXY (0,0); Series2->AddXY (0,0);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn2Click (TObject *Sender)
{
User->ShowModal ();
ADOQuery1->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn1Click (TObject *Sender)
{
for (int i = 0; i < StringGrid1->ColCount; i++)
for (int j = 0; j < StringGrid1->RowCount; j++)
StringGrid1->Cells [i] [j] = "";
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: DBGrid1DblClick (TObject *Sender)
{
ReUser->ShowModal ();
ADOQuery1->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn3Click (TObject *Sender)
{
ShellExecute (0,0,Application->ExeName. c_str (),0,0,SW_SHOW); // Запускаем новую копию
Close (); // Закрываем старую
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn4Click (TObject *Sender)
{
Varianty->ShowModal ();
ADOQuery3->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: N2Click (TObject *Sender)
{
Close ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: DBGrid3DblClick (TObject *Sender)
{
ReVarianty->ShowModal ();
ADOQuery3->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn5Click (TObject *Sender)
{
Vopros->ShowModal ();
ADOQuery11->Requery ();
ADOQuery12->Requery ();
ADOQuery13->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button8Click (TObject *Sender)
{
if (PageControl3->ActivePageIndex==1)
{
Button2Click (Sender);
}
else if (PageControl3->ActivePageIndex==2)
{
Button4Click (Sender);
}
else if (PageControl3->ActivePageIndex==3)
{
Button6Click (Sender);
}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: PageControl3Change (TObject *Sender)
{
if (PageControl3->ActivePageIndex==0) Button8->Enabled=false;
else Button8->Enabled=true;
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button7Click (TObject *Sender)
{
ADOQuery0->Close ();
ADOQuery0->SQL->Clear ();
ADOQuery0->SQL->Text="select * from variant inner join auth on variant. nomervariant=auth. variant where auth. login='"+TabSheet2->Caption+"'";
ADOQuery0->Open ();
ShellExecute (Handle, "open", ADOQuery0->FieldByName ("FilePath") - >AsString. c_str (), 0, 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Server1ClientRead (TObject *Sender,
TCustomWinSocket *Socket)
{
logg (Socket->ReceiveText ()); // Записываем в лог данные
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn6Click (TObject *Sender)
{
Memo1->Lines->SaveToFile (path+"\db\\run\\run. cpp");
AnsiString a=path+"\db\\run\\run. bat";
AnsiString b=path+"\db\\run\\run. cpp "+path+"\db\\run\\ run";
ShellExecute (Handle, "open", a. c_str (), b. c_str (), 0, SW_SHOWNORMAL);
Timer1->Enabled=true;
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn7Click (TObject *Sender)
{
Timer2->Enabled=true;
Memo2->Lines->SaveToFile (path+"\db\\omp\\OpenMP. cpp");
AnsiString a=path+"\db\\omp\\OpenMP. bat";
AnsiString b=path+"\db\\omp\\OpenMP. cpp "+path+"\db\\omp\\ OpenMP";
ShellExecute (Handle, "open", a. c_str (), b. c_str (), 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn8Click (TObject *Sender)
{
Timer3->Enabled=true;
Memo3->Lines->SaveToFile (path+"\db\\mpi\\MPI. cpp");
AnsiString a=path+"\db\\mpi\\MPI. bat";
AnsiString b=path+"\db\\mpi\\MPI. cpp "+path+"\db\\mpi\\ MPI "+CSpinEdit9->Text;
ShellExecute (Handle, "open", a. c_str (), b. c_str (), 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn9Click (TObject *Sender)
{
Timer4->Enabled=true;
Memo4->Lines->SaveToFile (path+"\db\\pthreads\\pthreads. cpp");
AnsiString a=path+"\db\\pthreads\\pthreads. bat";
AnsiString b=path+"\db\\pthreads\\pthreads. cpp "+path+"\db\\pthreads\\ pthreads";
ShellExecute (Handle, "open", a. c_str (), b. c_str (), 0, SW_SHOWNORMAL);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn11Click (TObject *Sender)
{
Memo1->Clear ();
Memo1->Lines->Add ("#include \"header. txt\"");
Memo1->Lines->Add ("#define steps "+CSpinEdit1->Text);
Memo1->Lines->Add ("#define N "+CSpinEdit2->Text);
Memo11->Lines->LoadFromFile (path+"\db\\run\\start. txt");
Memo1->Lines->Add (Memo11->Lines->Text);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn10Click (TObject *Sender)
{
Memo2->Clear ();
Memo2->Lines->Add ("#include \"header. txt\"");
Memo2->Lines->Add ("#define steps "+CSpinEdit3->Text);
Memo2->Lines->Add ("#define N "+CSpinEdit4->Text);
Memo2->Lines->Add ("#define cntThreads "+CSpinEdit10->Text);
Memo22->Lines->LoadFromFile (path+"\db\\omp\\start. txt");
Memo2->Lines->Add (Memo22->Lines->Text);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Timer1Timer (TObject *Sender)
{
if (FileExists (path+"\db\\run\\1. txt")) Memo111->Lines->LoadFromFile (path+"\db\\run\\1. txt");
if (FileExists (path+"\db\\run\\2. txt")) Memo112->Lines->LoadFromFile (path+"\db\\run\\2. txt");
DecimalSeparator = '. ';
Series1->AddXY (CSpinEdit2->Text. ToDouble (),Memo111->Text. ToDouble ());
Series2->AddXY (CSpinEdit2->Text. ToDouble (),Memo112->Text. ToDouble ());
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: N4Click (TObject *Sender)
{
Options->Edit1->Text=Ini->ReadString ("NetWork","IPAdress","192.168.1.1");
Options->Edit2->Text=Ini->ReadString ("NetWork","FilePathDB","");
Options->ShowModal ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormClose (TObject *Sender, TCloseAction &Action)
{
Server1->Close ();
Client1->Close ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Client1Error (TObject *Sender,
TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
ErrorCode=0;
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Server1ClientError (TObject *Sender,
TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
ErrorCode=0;
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Timer2Timer (TObject *Sender)
{
if (FileExists (path+"\db\\omp\\1. txt")) Memo211->Lines->LoadFromFile (path+"\db\\omp\\1. txt");
if (FileExists (path+"\db\\omp\\2. txt")) Memo212->Lines->LoadFromFile (path+"\db\\omp\\2. txt");
DecimalSeparator = '. ';
LineSeries1->AddXY (StrToFloat (CSpinEdit4->Text),StrToFloat (Memo211->Lines->Text));
LineSeries2->AddXY (StrToFloat (CSpinEdit4->Text),StrToFloat (Memo212->Lines->Text));
LineSeries9->AddXY (StrToFloat (CSpinEdit10->Text),StrToFloat (Memo212->Lines->Text));
LineSeries10->AddXY (StrToFloat (CSpinEdit10->Text),StrToFloat (Memo211->Lines->Text));
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn12Click (TObject *Sender)
{
Memo4->Clear ();
Memo4->Lines->Add ("#include \"header. txt\"");
Memo4->Lines->Add ("#define steps "+CSpinEdit7->Text);
Memo4->Lines->Add ("#define N "+CSpinEdit8->Text);
Memo4->Lines->Add ("#define cntThreads "+CSpinEdit11->Text);
Memo44->Lines->LoadFromFile (path+"\db\\pthreads\\start. txt");
Memo4->Lines->Add (Memo44->Lines->Text);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: BitBtn13Click (TObject *Sender)
{
Memo3->Clear ();
Memo3->Lines->Add ("#include \"header. txt\"");
Memo3->Lines->Add ("#define steps "+CSpinEdit6->Text);
Memo3->Lines->Add ("#define N "+CSpinEdit5->Text);
Memo33->Lines->LoadFromFile (path+"\db\\mpi\\start. txt");
Memo3->Lines->Add (Memo33->Lines->Text);
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: DBGrid4DblClick (TObject *Sender)
{
ReVopros->Sooow (Form1->ADOQuery11);
ReVopros->ShowModal ();
ADOQuery11->Requery ();
ADOQuery12->Requery ();
ADOQuery13->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: DBGrid5DblClick (TObject *Sender)
{
ReVopros->Sooow (Form1->ADOQuery12);
ReVopros->ShowModal ();
ADOQuery11->Requery ();
ADOQuery12->Requery ();
ADOQuery13->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: DBGrid6DblClick (TObject *Sender)
{
ReVopros->Sooow (Form1->ADOQuery13);
ReVopros->ShowModal ();
ADOQuery11->Requery ();
ADOQuery12->Requery ();
ADOQuery13->Requery ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button9Click (TObject *Sender)
{
Series1->Clear ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button10Click (TObject *Sender)
{
Series2->Clear ();
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Timer3Timer (TObject *Sender)
{
if (FileExists (path+"\db\\mpi\\1. txt")) Memo311->Lines->LoadFromFile (path+"\db\\mpi\\1. txt");
if (FileExists (path+"\db\\mpi\\2. txt")) Memo312->Lines->LoadFromFile (path+"\db\\mpi\\2. txt");
DecimalSeparator = '. ';
LineSeries3->AddXY (StrToFloat (CSpinEdit5->Text),StrToFloat (Memo311->Lines->Text));
LineSeries4->AddXY (StrToFloat (CSpinEdit5->Text),StrToFloat (Memo312->Lines->Text));
LineSeries8->AddXY (StrToFloat (CSpinEdit9->Text),StrToFloat (Memo312->Lines->Text));
LineSeries7->AddXY (StrToFloat (CSpinEdit9->Text),StrToFloat (Memo311->Lines->Text));
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Timer4Timer (TObject *Sender)
{
if (FileExists (path+"\db\\pthreads\\1. txt")) Memo411->Lines->LoadFromFile (path+"\db\\pthreads\\1. txt");
if (FileExists (path+"\db\\pthreads\\2. txt")) Memo412->Lines->LoadFromFile (path+"\db\\pthreads\\2. txt");
Подобные документы
Система дистанционного обучения Distance Learning Belarus и лабораторный практикум курса "Разработка трансляторов для языков программирования", его перенос в интерактивную среду обучения. Описание работы программы и её взаимодействия с пользователями.
курсовая работа [588,5 K], добавлен 03.11.2012Система дистанционного обучения Distance Learning Belarus. Разработка лабораторного практикума по курсу "Разработка трансляторов для языков программирования". Базовые концепции разработки приложений для Интернет. Схема диалога пользователя с системой.
курсовая работа [1,3 M], добавлен 03.11.2012Принципы работы и редактирования в программе Adobe Audition 3.0, вид пользовательского интерфейса и функциональные возможности. Разработка лабораторного практикума и учебно-практического пособия. Мероприятия по обеспечению безопасности при работе на ПК.
дипломная работа [4,9 M], добавлен 12.04.2012Особенности и классификация программных комплексов, их обзор и функциональные возможности в сфере обучения. Объектно-ориентированное проектирование компьютерного практикума. Разработка и структура информационного обеспечения, основные требования к нему.
дипломная работа [3,3 M], добавлен 19.01.2017Выбор инструментальных средств для разработки лабораторного практикума по работе с операционной системой Windows ХР. Рекомендации по установке виртуальной машины. Подключение жесткого диска, его разделение на разделы. Управление пользователями и группами.
дипломная работа [4,7 M], добавлен 17.08.2013Рассмотрение методик применения цифровых образовательных ресурсов в информационно–телекоммуникационном сопровождении системы образования. Функции компьютера на уроках. Содержание и методика проведения работы по созданию практикума "Электронные таблицы".
курсовая работа [829,9 K], добавлен 03.07.2015Особенности дистанционного образования. Разработка электронного практикума по дисциплине "Методы и средства проектирования информационных систем и технологий". Предметная область, выделение информационных объектов. Разработка программного обеспечения.
дипломная работа [2,1 M], добавлен 27.10.2017Виртуальный лабораторный практикум в инженерном образовании. Особенности лабораторного практикума для естественнонаучных дисциплин. Программный эмулятор (виртуальный ПК) Emu8086. Вывод значения байта в десятеричной системе счисления, методика выполнения.
дипломная работа [430,2 K], добавлен 09.07.2010Характеристика микроконтроллера: тип, корпуса и выводы, перечень битов конфигурации и идентификаторов. Разработка и изготовление лабораторного блока для программирования бутлоадера в микроконтроллер: блок-схема устройства, изготовление печатной платы.
дипломная работа [1,7 M], добавлен 07.06.2012Математическая основа параллельных вычислений. Свойства Parallel Computing Toolbox. Разработка параллельных приложений в Matlab. Примеры программирования параллельных задач. Вычисление определенного интеграла. Последовательное и параллельное перемножение.
курсовая работа [1,1 M], добавлен 15.12.2010
